mycode-cli 0.19.0__tar.gz → 0.19.1__tar.gz

{mycode_cli-0.19.0 → mycode_cli-0.19.1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.5
 Name: mycode-cli
-Version: 0.19.0
+Version: 0.19.1
 Summary: Minimal coding agent CLI and web UI built on mycode-sdk.
 Project-URL: Homepage, https://github.com/legibet/mycode
 Project-URL: Repository, https://github.com/legibet/mycode
@@ -25,7 +25,7 @@ Requires-Dist: beautifulsoup4>=4.15.0
 Requires-Dist: fastapi>=0.139.0
 Requires-Dist: httpx2>=2.10.0
 Requires-Dist: markdownify>=1.2.3
-Requires-Dist: mycode-sdk==0.19.0
+Requires-Dist: mycode-sdk==0.19.1
 Requires-Dist: prompt-toolkit>=3.0.52
 Requires-Dist: pydantic>=2.13.4
 Requires-Dist: pygments>=2.20.0

{mycode_cli-0.19.0 → mycode_cli-0.19.1}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "hatchling.build"
 
 [project]
 name = "mycode-cli"
-version = "0.19.0"
+version = "0.19.1"
 description = "Minimal coding agent CLI and web UI built on mycode-sdk."
 readme = "README.md"
 requires-python = ">=3.12"
@@ -26,7 +26,7 @@ classifiers = [
 ]
 keywords = ["agent", "cli", "llm", "coding-agent", "fastapi"]
 dependencies = [
-    "mycode-sdk==0.19.0",
+    "mycode-sdk==0.19.1",
     "fastapi>=0.139.0",
     "uvicorn[standard]>=0.51.0",
     "rich>=15.0.0",

{mycode_cli-0.19.0 → mycode_cli-0.19.1}/src/mycode_cli/server/routers/chat.py

@@ -3,6 +3,7 @@
 from __future__ import annotations
 
 import asyncio
+import io
 import json
 import os
 from base64 import b64encode
@@ -10,6 +11,7 @@ from collections.abc import AsyncIterator
 from dataclasses import replace
 from pathlib import Path
 from typing import Annotated, Any, cast
+from uuid import uuid4
 
 from fastapi import APIRouter, HTTPException, Query, Request
 from fastapi import Path as PathParam
@@ -58,7 +60,8 @@ from mycode_cli.server.schemas import (
     UserInputRequest,
 )
 from mycode_cli.system_prompt import build_skill_snapshot_blocks, discover_slash_skills
-from mycode_cli.workspace import resolve_path
+from mycode_cli.tools import read_text_window
+from mycode_cli.workspace import CliDeps, resolve_path
 
 router = APIRouter()
 
@@ -72,7 +75,7 @@ def _resolve_workspace_attachment_path(rel_path: str, *, cwd: str) -> Path:
 
 
 def _read_workspace_text_attachment(rel_path: str, *, name: str | None, cwd: str) -> list[dict[str, Any]]:
-    """Read a workspace text file selected via the @ menu into a `<file>` block.
+    """Read a workspace text file selected via the @ menu into a `<file>` block, bounded like ``read``.
 
     Re-validates the path at send time: it must resolve inside ``cwd`` (guards
     against a symlink swapped in after selection), be a regular file, and be
@@ -84,16 +87,40 @@ def _read_workspace_text_attachment(rel_path: str, *, name: str | None, cwd: str
     if detect_image_mime_type(path) or detect_document_mime_type(path):
         raise HTTPException(status_code=400, detail=f"not a text file: {rel_path}")
     try:
-        return build_attachment_blocks([Attachment.path(path, name=name or rel_path)])
-    except ValueError as exc:
-        raise HTTPException(status_code=400, detail=str(exc)) from exc
+        with path.open(encoding="utf-8") as file:
+            window = read_text_window(file)
+    except UnicodeDecodeError as exc:
+        raise HTTPException(status_code=400, detail=f"not UTF-8 text: {rel_path}") from exc
+    return build_attachment_blocks([Attachment.text(window.render(path), name=name or rel_path)])
+
+
+def _write_uploads(uploads: dict[Path, str]) -> None:
+    for path, text in uploads.items():
+        path.parent.mkdir(parents=True, exist_ok=True)
+        path.write_text(text, encoding="utf-8")
+
+
+def _remove_uploads(uploads: dict[Path, str]) -> None:
+    """Undo ``_write_uploads`` for a message the run refused."""
+
+    for path in uploads:
+        path.unlink(missing_ok=True)
 
 
-async def _build_user_message(chat: UserInputRequest, cwd: str) -> ConversationMessage:
+async def _build_user_message(chat: UserInputRequest, deps: CliDeps) -> tuple[ConversationMessage, dict[Path, str]]:
+    """Build the user message and the uploads to save before it is sent.
+
+    A text upload that does not fit one read window is shown truncated, and its
+    full text is returned for ``tool_output_dir`` so the model can read the rest.
+    The caller writes it once the request has passed validation.
+    """
+
+    cwd = str(deps.cwd)
+    uploads: dict[Path, str] = {}
     if not chat.input:
         text = str(chat.message or "").strip()
         snapshots = await asyncio.to_thread(build_skill_snapshot_blocks, text, cwd)
-        return build_message("user", [*snapshots, text_block(text)])
+        return build_message("user", [*snapshots, text_block(text)]), uploads
 
     blocks: list[dict[str, Any]] = []
     visible_text: list[str] = []
@@ -106,7 +133,12 @@ async def _build_user_message(chat: UserInputRequest, cwd: str) -> ConversationM
                 continue
             text = block.text or ""
             if block.is_attachment:
-                blocks.extend(build_attachment_blocks([Attachment.text(text, name=str(block.name or "attached-file"))]))
+                name = str(block.name or "attached-file")
+                window = read_text_window(io.StringIO(text, newline=None))
+                upload_path = deps.tool_output_dir / f"upload-{uuid4().hex}"
+                if window.partial:
+                    uploads[upload_path] = text
+                blocks.extend(build_attachment_blocks([Attachment.text(window.render(upload_path), name=name)]))
             elif text:
                 visible_text.append(text)
                 blocks.append(text_block(text))
@@ -143,7 +175,7 @@ async def _build_user_message(chat: UserInputRequest, cwd: str) -> ConversationM
         raise HTTPException(status_code=400, detail="input must include at least one non-empty block")
     snapshots = await asyncio.to_thread(build_skill_snapshot_blocks, "\n".join(visible_text), cwd)
     blocks[:0] = snapshots
-    return build_message("user", blocks)
+    return build_message("user", blocks), uploads
 
 
 def _check_input_support(message: ConversationMessage, model: ModelMetadata | RunAgent) -> None:
@@ -193,7 +225,9 @@ async def chat(chat: ChatRequest, store: StoreDep, runs: RunManagerDep) -> ChatR
         api_base=chat.api_base,
     )
     session_id = chat.session_id or "default"
-    user_message = await _build_user_message(chat, cwd)
+    user_message, uploads = await _build_user_message(
+        chat, CliDeps.for_session(cwd=cwd, data_dir=store.data_dir, session_id=session_id)
+    )
 
     # Capability check before any disk mutation — a failed check must not
     # leave an empty session on disk or land a premature rewind marker.
@@ -248,9 +282,10 @@ async def chat(chat: ChatRequest, store: StoreDep, runs: RunManagerDep) -> ChatR
             existing_messages = data["messages"] if data else []
             _validate_rewind_request(session=session, messages=existing_messages, rewind_to=chat.rewind_to)
 
-        # All validation passed. Land the rewind marker (if any) and register
-        # the user turn in the catalog: first turn creates the entry and sets
-        # the title, later turns bump updated_at.
+        # All validation passed. Save uploads, land the rewind marker (if any)
+        # and register the user turn in the catalog: first turn creates the
+        # entry and sets the title, later turns bump updated_at.
+        await asyncio.to_thread(_write_uploads, uploads)
         if chat.rewind_to is not None:
             await store.append_rewind(session_id, chat.rewind_to)
         session = await store.record_user_turn(
@@ -398,17 +433,22 @@ async def compact_session(
 
 @router.post("/runs/{run_id}/steer")
 async def steer_run(
-    run_id: Annotated[str, PathParam(min_length=1)], body: PendingInputRequest, runs: RunManagerDep
+    run_id: Annotated[str, PathParam(min_length=1)], body: PendingInputRequest, store: StoreDep, runs: RunManagerDep
 ) -> RunResponse:
     """Hand a user message to the running chat for its next step boundary."""
 
     state = await runs.get_run(run_id)
     if state is None:
         raise HTTPException(status_code=404, detail="run not found")
-    message = await _build_user_message(body, state.cwd)
+    message, uploads = await _build_user_message(
+        body, CliDeps.for_session(cwd=state.cwd, data_dir=store.data_dir, session_id=state.session_id)
+    )
     message["meta"] = {"input_id": body.input_id}
     _check_input_support(message, state.agent)
+    # Uploads are on disk before the model can see the message; a refusal removes them.
+    await asyncio.to_thread(_write_uploads, uploads)
     if not state.agent.steer(message):
+        await asyncio.to_thread(_remove_uploads, uploads)
         raise HTTPException(
             status_code=409,
             detail={"message": "run is not accepting steers", "run": state.info()},
@@ -428,10 +468,14 @@ async def queue_message(
     state = await runs.get_active_run(session_id)
     if state is None:
         raise HTTPException(status_code=409, detail={"message": "session has no running chat to queue on"})
-    message = await _build_user_message(body, state.cwd)
+    message, uploads = await _build_user_message(
+        body, CliDeps.for_session(cwd=state.cwd, data_dir=store.data_dir, session_id=session_id)
+    )
     message["meta"] = {"input_id": body.input_id}
     _check_input_support(message, state.agent)
+    await asyncio.to_thread(_write_uploads, uploads)
     if not await runs.enqueue(state, message):
+        await asyncio.to_thread(_remove_uploads, uploads)
         raise HTTPException(status_code=409, detail={"message": "session has no running chat to queue on"})
     await store.record_user_turn(
         session_id,

{mycode_cli-0.19.0 → mycode_cli-0.19.1}/src/mycode_cli/tools.py

@@ -20,7 +20,7 @@ from contextlib import suppress
 from dataclasses import dataclass
 from difflib import SequenceMatcher, unified_diff
 from pathlib import Path
-from typing import BinaryIO
+from typing import BinaryIO, TextIO
 from uuid import uuid4
 
 from pydantic import BaseModel, ConfigDict, Field
@@ -37,6 +37,7 @@ from mycode_cli.workspace import CliDeps, resolve_path
 DEFAULT_MAX_LINES = 2000
 DEFAULT_MAX_BYTES = 50 * 1024
 READ_MAX_LINE_CHARS = 2000
+_READ_SKIP_CHUNK_CHARS = 64 * 1024
 BASH_TIMEOUT_SECONDS = 120
 _BASH_READ_CHUNK_SIZE = 64 * 1024
 
@@ -46,6 +47,110 @@ _BASH_READ_CHUNK_SIZE = 64 * 1024
 # ---------------------------------------------------------------------------
 
 
+@dataclass(frozen=True)
+class TextWindow:
+    """One bounded read of a text file: the lines that fit and what was left out."""
+
+    text: str
+    start_line: int
+    # Lines consumed from the top of the file, skipped ones included.
+    lines_read: int
+    # First line not shown because a line or byte limit was reached.
+    next_offset: int | None
+    first_shortened_line: int | None
+    shortened_lines: int
+
+    @property
+    def partial(self) -> bool:
+        """Whether part of the file from ``start_line`` on is not in ``text``."""
+
+        return self.next_offset is not None or self.shortened_lines > 0
+
+    def render(self, path: Path) -> str:
+        """Return ``text`` followed by notices telling the model how to read what was left out of ``path``."""
+
+        parts = [self.text] if self.text else []
+        if self.next_offset is not None:
+            parts.append(
+                f"[Showing lines {self.start_line}-{self.next_offset - 1} of {path}. "
+                + f"Use read with offset={self.next_offset} to continue.]"
+            )
+        if self.first_shortened_line is not None:
+            quoted = shlex.quote(str(path))
+            line = self.first_shortened_line
+            prefix = f"[Line {line} was shortened to {READ_MAX_LINE_CHARS} chars."
+            if self.shortened_lines > 1:
+                prefix = (
+                    f"[{self.shortened_lines} lines were shortened to {READ_MAX_LINE_CHARS} chars. "
+                    f"First shortened line: {line}."
+                )
+            parts.append(
+                f"{prefix}\n"
+                + "Use bash to inspect it in bytes:\n"
+                + f"sed -n '{line}p' {quoted} | head -c 2000\n"
+                + f"sed -n '{line}p' {quoted} | tail -c +2001 | head -c 2000]"
+            )
+        return "\n\n".join(parts)
+
+
+def read_text_window(file: TextIO, *, offset: int = 1, limit: int = DEFAULT_MAX_LINES) -> TextWindow:
+    """Read up to ``limit`` lines from 1-indexed ``offset``, capped at ``DEFAULT_MAX_BYTES`` of UTF-8.
+
+    At most ``READ_MAX_LINE_CHARS + 1`` chars of a line are held at once; longer
+    lines are shortened. Reading stops once the window is full, without
+    scanning the line that did not fit.
+    """
+
+    lines: list[str] = []
+    size = 0
+    lines_read = 0
+    next_offset: int | None = None
+    first_shortened_line: int | None = None
+    shortened_lines = 0
+    while True:
+        if len(lines) >= limit:
+            # Probe one char instead of reading a possibly huge next line.
+            if file.read(1):
+                next_offset = lines_read + 1
+            break
+        head = file.readline(READ_MAX_LINE_CHARS + 1)
+        if not head:
+            break
+        lines_read += 1
+        shortened = not head.endswith("\n") and len(head) > READ_MAX_LINE_CHARS
+        if lines_read < offset:
+            if shortened:
+                _skip_line(file)
+            continue
+        line = head[:READ_MAX_LINE_CHARS] + " ... [line truncated]" if shortened else head.rstrip("\r\n")
+        line_bytes = len(line.encode("utf-8")) + 1
+        # A shortened line is at most a few KB, so the first line always fits.
+        if size + line_bytes > DEFAULT_MAX_BYTES:
+            next_offset = lines_read
+            break
+        if shortened:
+            _skip_line(file)
+            first_shortened_line = first_shortened_line or lines_read
+            shortened_lines += 1
+        lines.append(line)
+        size += line_bytes
+    return TextWindow(
+        text="\n".join(lines),
+        start_line=offset,
+        lines_read=lines_read,
+        next_offset=next_offset,
+        first_shortened_line=first_shortened_line,
+        shortened_lines=shortened_lines,
+    )
+
+
+def _skip_line(file: TextIO) -> None:
+    """Consume the rest of the current line in bounded chunks."""
+
+    while (rest := file.readline(_READ_SKIP_CHUNK_CHARS)) and not rest.endswith("\n"):
+        pass
+
+
 @tool(
     name="read",
     description=(
@@ -94,28 +199,9 @@ def read_tool(
 
     start_line = offset if offset is not None and offset > 0 else 1
     line_limit = limit if limit is not None and limit > 0 else DEFAULT_MAX_LINES
-    lines: list[str] = []
-    total_lines = 0
-    next_offset: int | None = None
-    first_shortened_line: int | None = None
-    shortened_lines = 0
-
     try:
         with file_path.open("r", encoding="utf-8") as f:
-            for total_lines, raw_line in enumerate(f, start=1):
-                if total_lines < start_line:
-                    continue
-                if len(lines) >= line_limit:
-                    next_offset = total_lines
-                    break
-
-                line = raw_line.rstrip("\r\n")
-                if len(line) > READ_MAX_LINE_CHARS:
-                    if first_shortened_line is None:
-                        first_shortened_line = total_lines
-                    shortened_lines += 1
-                    line = line[:READ_MAX_LINE_CHARS] + " ... [line truncated]"
-                lines.append(line)
+            window = read_text_window(f, offset=start_line, limit=line_limit)
     except FileNotFoundError:
         return ToolExecutionResult(output=f"error: file not found: {path}", is_error=True)
     except IsADirectoryError:
@@ -125,37 +211,13 @@ def read_tool(
     except Exception as exc:
         return ToolExecutionResult(output=f"error: failed to read file: {exc}", is_error=True)
 
-    if total_lines < start_line and not (total_lines == 0 and start_line == 1):
+    if window.lines_read < start_line and not (window.lines_read == 0 and start_line == 1):
         return ToolExecutionResult(
-            output=f"error: offset {offset} beyond end of file ({total_lines} lines)",
+            output=f"error: offset {offset} beyond end of file ({window.lines_read} lines)",
             is_error=True,
         )
 
-    parts: list[str] = []
-    content = "\n".join(lines)
-    if content:
-        parts.append(content)
-
-    if next_offset is not None:
-        parts.append(f"[Showing lines {start_line}-{next_offset - 1}. Use offset={next_offset} to continue.]")
-
-    if first_shortened_line is not None:
-        quoted = shlex.quote(str(file_path))
-        prefix = f"[Line {first_shortened_line} was shortened to {READ_MAX_LINE_CHARS} chars."
-        if shortened_lines > 1:
-            prefix = (
-                f"[{shortened_lines} lines were shortened to {READ_MAX_LINE_CHARS} chars. "
-                f"First shortened line: {first_shortened_line}."
-            )
-        parts.append(
-            f"{prefix}\n"
-            + "Use bash to inspect it in bytes:\n"
-            + f"sed -n '{first_shortened_line}p' {quoted} | head -c 2000\n"
-            + f"sed -n '{first_shortened_line}p' {quoted} | tail -c +2001 | head -c 2000]"
-        )
-
-    joined = "\n\n".join(parts) if parts else ""
-    return ToolExecutionResult(output=joined)
+    return ToolExecutionResult(output=window.render(file_path))
 
 
 # ---------------------------------------------------------------------------

{mycode_cli-0.19.0 → mycode_cli-0.19.1}/src/mycode_cli/tui/chat.py

@@ -52,6 +52,7 @@ from mycode_cli.runtime import load_session_totals
 from mycode_cli.sessions import SessionStore
 from mycode_cli.state import load_state, save_state
 from mycode_cli.system_prompt import build_skill_snapshot_blocks, discover_slash_skills
+from mycode_cli.tools import read_text_window
 from mycode_cli.workspace import CliDeps, resolve_path
 
 from .render import (
@@ -584,13 +585,16 @@ class TerminalChat:
                     unsupported_attachment_block(name=path_text, mime_type=pdf, kind="document", path=path_text)
                 )
                 continue
-            # Text snippets keep the resolved path as the visible name; image/PDF default to the basename.
-            # A non-UTF-8 binary raises ValueError inside build_attachment_blocks and is skipped.
-            name = None if img or pdf else path_text
+            if img or pdf:
+                blocks.extend(build_attachment_blocks([Attachment.path(path)]))
+                continue
+            # Text keeps the resolved path as its visible name; a non-UTF-8 binary is skipped.
             try:
-                blocks.extend(build_attachment_blocks([Attachment.path(path_text, name=name)]))
-            except ValueError:
+                with path.open(encoding="utf-8") as file:
+                    window = read_text_window(file)
+            except UnicodeDecodeError:
                 continue
+            blocks.extend(build_attachment_blocks([Attachment.text(window.render(path), name=path_text)]))
 
         return build_message("user", blocks)
 

{mycode_cli-0.19.0 → mycode_cli-0.19.1}/src/mycode_cli/tui/terminal.py

@@ -28,7 +28,7 @@ from prompt_toolkit.key_binding import ConditionalKeyBindings, KeyBindings, merg
 from prompt_toolkit.key_binding.defaults import load_key_bindings
 from prompt_toolkit.key_binding.key_processor import KeyPressEvent
 from prompt_toolkit.keys import Keys
-from prompt_toolkit.layout import ConditionalContainer, Float, FloatContainer, HSplit, Layout, Window
+from prompt_toolkit.layout import ConditionalContainer, Float, FloatContainer, HSplit, Layout, ScrollOffsets, Window
 from prompt_toolkit.layout.controls import BufferControl, FormattedTextControl
 from prompt_toolkit.layout.dimension import Dimension
 from prompt_toolkit.layout.menus import CompletionsMenu
@@ -198,6 +198,8 @@ class Terminal:
             height=lambda: Dimension(max=self.tail_height),
             dont_extend_height=True,
             always_hide_cursor=True,
+            # Keeps the heading above a group's first row in view when scrolling up.
+            scroll_offsets=ScrollOffsets(top=1),
         )
 
         busy = Condition(lambda: self._busy)