deepy-cli 0.1.6__tar.gz → 0.1.8__tar.gz

{deepy_cli-0.1.6 → deepy_cli-0.1.8}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.3
 Name: deepy-cli
-Version: 0.1.6
+Version: 0.1.8
 Summary: Deepy - Vibe coding for DeepSeek models in your terminal
 Keywords: deepseek,coding-agent,terminal,cli,agents
 Author: kirineko
@@ -238,5 +238,5 @@ assets live outside the package directory and are not included in the wheel.
 
 ## Release Status
 
-Deepy `0.1.6` is released through GitHub and PyPI. Standalone binaries and npm
+Deepy `0.1.8` is released through GitHub and PyPI. Standalone binaries and npm
 wrappers can be added later, but the primary distribution is the Python CLI.

{deepy_cli-0.1.6 → deepy_cli-0.1.8}/README.md

@@ -210,5 +210,5 @@ assets live outside the package directory and are not included in the wheel.
 
 ## Release Status
 
-Deepy `0.1.6` is released through GitHub and PyPI. Standalone binaries and npm
+Deepy `0.1.8` is released through GitHub and PyPI. Standalone binaries and npm
 wrappers can be added later, but the primary distribution is the Python CLI.

{deepy_cli-0.1.6 → deepy_cli-0.1.8}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "deepy-cli"
-version = "0.1.6"
+version = "0.1.8"
 description = "Deepy - Vibe coding for DeepSeek models in your terminal"
 readme = "README.md"
 authors = [

{deepy_cli-0.1.6 → deepy_cli-0.1.8}/src/deepy/__init__.py

@@ -1,6 +1,6 @@
 from __future__ import annotations
 
-__version__ = "0.1.6"
+__version__ = "0.1.8"
 
 
 def main() -> None:

{deepy_cli-0.1.6 → deepy_cli-0.1.8}/src/deepy/data/tools/WebFetch.md

@@ -5,5 +5,6 @@ Fetch a specific web page when the user provides a complete URL.
 Args: `url`.
 
 Accepts only complete `http://` or `https://` URLs. Returns the final URL, title,
-content type, and extracted readable text for HTML pages. Use `WebSearch` to
+content type, and extracted readable text for HTML pages, including standard
+description metadata when ordinary body text is unavailable. Use `WebSearch` to
 discover URLs; use `WebFetch` when the URL is already known.

{deepy_cli-0.1.6 → deepy_cli-0.1.8}/src/deepy/data/tools/shell.md

@@ -9,5 +9,9 @@ Use the runtime context's command dialect and path style: PowerShell uses
 PowerShell commands and Windows paths, `cmd` uses cmd syntax, and `posix` uses
 POSIX shell syntax.
 
+On Windows PowerShell, Python child processes run with UTF-8 I/O defaults for
+the command invocation; do not ask users to run `chcp` or change their
+PowerShell profile for Unicode output.
+
 Runs in the session cwd, preserves cwd between calls when supported, and returns
 stdout/stderr JSON with cwd, exit-code, and shell metadata.

{deepy_cli-0.1.6 → deepy_cli-0.1.8}/src/deepy/sessions/jsonl.py

@@ -13,6 +13,8 @@ from deepy.utils import json as json_utils
 
 SESSION_INDEX_VERSION = 2
 MAX_SESSION_INDEX_ENTRIES = 50
+CONTEXT_UNDERCOUNT_REPAIR_RATIO = 2
+CONTEXT_UNDERCOUNT_REPAIR_MIN_DELTA = 128
 
 
 @dataclass(frozen=True)
@@ -147,11 +149,13 @@ class DeepyJsonlSession:
             return
         previous = _entry_for_session(self.path.parent / "sessions-index.json", self.session_id)
         accumulated = merge_usage(previous.get("usage") if previous else None, normalized)
+        current_state = self.context_token_state()
+        checkpoint_tokens = max(normalized.prompt_tokens, current_state.active_tokens)
         record_count = len(self._load_records())
         self._touch_index(
-            active_tokens=normalized.prompt_tokens,
+            active_tokens=checkpoint_tokens,
             usage=accumulated.to_dict(),
-            last_usage_tokens=normalized.prompt_tokens,
+            last_usage_tokens=checkpoint_tokens,
             pending_tokens=0,
             last_usage_record_count=record_count,
         )
@@ -166,13 +170,27 @@ class DeepyJsonlSession:
             last_usage_tokens = _optional_int(previous.get("lastUsageTokens"))
             last_usage_record_count = _optional_int(previous.get("lastUsageRecordCount"))
             if last_usage_tokens is not None and last_usage_record_count is not None:
-                bounded_count = max(0, min(last_usage_record_count, len(source)))
-                pending_tokens = sum(_estimate_record_tokens(record) for record in source[bounded_count:])
+                if last_usage_record_count > len(source):
+                    active_tokens = self._estimate_active_tokens(source)
+                    return ContextTokenState(
+                        active_tokens=active_tokens,
+                        last_usage_tokens=None,
+                        pending_tokens=0,
+                        last_usage_record_count=None,
+                        estimated=True,
+                    )
+                pending_tokens = sum(_estimate_record_tokens(record) for record in source[last_usage_record_count:])
+                checkpoint_tokens = last_usage_tokens + pending_tokens
+                estimated_tokens = self._estimate_active_tokens(source)
+                active_tokens = _repair_undercounted_context_tokens(
+                    checkpoint_tokens,
+                    estimated_tokens,
+                )
                 return ContextTokenState(
-                    active_tokens=last_usage_tokens + pending_tokens,
+                    active_tokens=active_tokens,
                     last_usage_tokens=last_usage_tokens,
-                    pending_tokens=pending_tokens,
-                    last_usage_record_count=bounded_count,
+                    pending_tokens=max(active_tokens - last_usage_tokens, pending_tokens),
+                    last_usage_record_count=last_usage_record_count,
                     estimated=True,
                 )
         active_tokens = self._estimate_active_tokens(source)
@@ -348,6 +366,9 @@ class DeepyJsonlSession:
 
 @dataclass(frozen=True)
 class ContextTokenState:
+    # active_tokens is the effective context pressure used by UI and auto compaction.
+    # last_usage_tokens is the latest checkpoint covered by usage or session rewrite.
+    # pending_tokens estimates records appended after that checkpoint.
     active_tokens: int
     last_usage_tokens: int | None = None
     pending_tokens: int = 0
@@ -452,3 +473,14 @@ def _estimate_record_tokens(record: dict[str, Any]) -> int:
     if item is not None:
         return estimate_tokens_for_item(item)
     return estimate_tokens_for_item(record.get("content", ""))
+
+
+def _repair_undercounted_context_tokens(checkpoint_tokens: int, estimated_tokens: int) -> int:
+    if estimated_tokens <= checkpoint_tokens:
+        return checkpoint_tokens
+    if (
+        estimated_tokens - checkpoint_tokens >= CONTEXT_UNDERCOUNT_REPAIR_MIN_DELTA
+        and estimated_tokens >= checkpoint_tokens * CONTEXT_UNDERCOUNT_REPAIR_RATIO
+    ):
+        return estimated_tokens
+    return checkpoint_tokens

{deepy_cli-0.1.6 → deepy_cli-0.1.8}/src/deepy/tools/builtin.py

@@ -38,6 +38,7 @@ MAX_BASH_OUTPUT_CHARS = 30_000
 MAX_BASH_CAPTURE_CHARS = 10 * 1024 * 1024
 MAX_WEB_FETCH_BYTES = 2 * 1024 * 1024
 MAX_WEB_FETCH_OUTPUT_CHARS = 30_000
+MIN_USEFUL_WEB_FETCH_BODY_CHARS = 40
 DEFAULT_WEB_SEARCH_URL = "https://html.duckduckgo.com/html/"
 DEFAULT_WEB_SEARCH_RESULTS = 8
 MAX_WEB_SEARCH_CALLS_PER_TURN = 8
@@ -207,6 +208,7 @@ class ShellInvocation:
     shell_path: str
     args: list[str]
     runtime_environment: RuntimeEnvironment
+    env: dict[str, str] | None = None
 
 
 def _find_occurrences(text: str, needle: str, scope: tuple[int, int]) -> list[MatchOccurrence]:
@@ -942,12 +944,15 @@ class _ReadableHtmlParser(HTMLParser):
         super().__init__(convert_charrefs=True)
         self.title_parts: list[str] = []
         self.text_parts: list[str] = []
+        self.description_candidates: dict[str, str] = {}
         self._in_title = False
         self._skip_depth = 0
 
     def handle_starttag(self, tag: str, attrs: list[tuple[str, str | None]]) -> None:
-        del attrs
         normalized = tag.lower()
+        if normalized == "meta":
+            self._record_meta_description(attrs)
+            return
         if normalized in self.SKIP_TAGS:
             self._skip_depth += 1
             return
@@ -994,6 +999,27 @@ class _ReadableHtmlParser(HTMLParser):
         raw = re.sub(r"\n{3,}", "\n\n", raw)
         return "\n".join(line.strip() for line in raw.splitlines()).strip()
 
+    @property
+    def meta_description(self) -> str:
+        for key in ("description", "og:description", "twitter:description"):
+            text = self.description_candidates.get(key, "").strip()
+            if text:
+                return text
+        return ""
+
+    def _record_meta_description(self, attrs: list[tuple[str, str | None]]) -> None:
+        attr_map = {name.lower(): value for name, value in attrs if value is not None}
+        raw_key = attr_map.get("name") or attr_map.get("property")
+        content = attr_map.get("content", "")
+        if not raw_key or not content:
+            return
+        key = raw_key.strip().lower()
+        if key not in {"description", "og:description", "twitter:description"}:
+            return
+        normalized = " ".join(content.split()).strip()
+        if normalized and key not in self.description_candidates:
+            self.description_candidates[key] = normalized
+
 
 def _validate_web_fetch_url(url: str) -> tuple[str | None, str | None]:
     stripped = url.strip()
@@ -1016,11 +1042,31 @@ def _is_html_response(content_type: str, text: str) -> bool:
     return "<html" in prefix or "<!doctype html" in prefix
 
 
-def _extract_readable_html(html: str) -> tuple[str, str]:
+def _extract_readable_html(html: str) -> tuple[str, str, str]:
     parser = _ReadableHtmlParser()
     parser.feed(html)
     parser.close()
-    return parser.title, parser.readable_text
+    return parser.title, parser.readable_text, parser.meta_description
+
+
+def _select_web_fetch_html_text(readable_text: str, metadata_text: str) -> str:
+    stripped = readable_text.strip()
+    if stripped and _is_useful_web_fetch_body_text(stripped):
+        return stripped
+    return metadata_text.strip() or stripped
+
+
+def _is_useful_web_fetch_body_text(text: str) -> bool:
+    normalized = " ".join(text.split()).strip().lower()
+    if len(normalized) >= MIN_USEFUL_WEB_FETCH_BODY_CHARS:
+        return True
+    return normalized not in {
+        "",
+        "loading",
+        "loading...",
+        "please enable javascript",
+        "you need to enable javascript to run this app.",
+    }
 
 
 def _format_web_fetch_output(
@@ -1354,6 +1400,7 @@ class ToolRuntime:
                 process = subprocess.Popen(
                     [shell_invocation.shell_path, *shell_invocation.args],
                     cwd=self.cwd,
+                    env=shell_invocation.env,
                     text=True,
                     stdout=stdout_file,
                     stderr=stderr_file,
@@ -1473,18 +1520,16 @@ class ToolRuntime:
         request = urllib.request.Request(
             target_url,
             headers={
-                "User-Agent": (
-                    "Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) "
-                    "AppleWebKit/537.36 (KHTML, like Gecko) Deepy/0.1"
-                ),
-                "Accept": "text/html,application/xhtml+xml,text/plain;q=0.9,*/*;q=0.8",
+                **WEB_SEARCH_BROWSER_HEADERS,
+                "Accept": "text/html,application/xhtml+xml,application/xml;q=0.9,text/plain;q=0.8,*/*;q=0.7",
             },
             method="GET",
         )
         try:
             with urllib.request.urlopen(request, timeout=30) as response:
                 final_url = response.geturl()
-                content_type = response.headers.get("Content-Type", "")
+                content_type = _response_header(response, "Content-Type") or ""
+                content_encoding = _response_header(response, "Content-Encoding")
                 body = response.read(MAX_WEB_FETCH_BYTES + 1)
         except Exception as exc:
             return ToolResult.error_result(
@@ -1501,9 +1546,24 @@ class ToolRuntime:
         bytes_truncated = len(body) > MAX_WEB_FETCH_BYTES
         body = body[:MAX_WEB_FETCH_BYTES]
         charset = _charset_from_content_type(content_type)
-        decoded = body.decode(charset, errors="replace")
+        try:
+            decoded = _decode_http_body(body, encoding=content_encoding, charset=charset)
+        except Exception as exc:
+            return ToolResult.error_result(
+                name,
+                f"WebFetch response decode failed: {exc}",
+                metadata={
+                    "url": target_url,
+                    "finalUrl": final_url,
+                    "contentType": content_type,
+                    "contentEncoding": content_encoding,
+                    "charset": charset,
+                    "activityLabel": activity_label,
+                },
+            ).to_json()
         if _is_html_response(content_type, decoded):
-            title, readable_text = _extract_readable_html(decoded)
+            title, readable_text, metadata_text = _extract_readable_html(decoded)
+            readable_text = _select_web_fetch_html_text(readable_text, metadata_text)
         else:
             title = ""
             readable_text = decoded.strip()
@@ -1692,8 +1752,7 @@ def _read_text_preserving_newlines(path: Path) -> str:
 def _read_text_metadata(path: Path) -> TextFileMetadata:
     data = path.read_bytes()
     encoding = _detect_text_encoding(data)
-    python_encoding = "utf-16" if encoding == "utf16le" else "utf-8"
-    text = data.decode(python_encoding, errors="replace")
+    text = data.decode(_python_text_encoding(encoding), errors="replace")
     return TextFileMetadata(
         content=text,
         encoding=encoding,
@@ -1704,12 +1763,32 @@ def _read_text_metadata(path: Path) -> TextFileMetadata:
 def _detect_text_encoding(data: bytes) -> str:
     if len(data) >= 2 and data[0] == 0xFF and data[1] == 0xFE:
         return "utf16le"
+    if data.startswith(b"\xef\xbb\xbf"):
+        return "utf8-sig"
+    try:
+        data.decode("utf-8", errors="strict")
+        return "utf8"
+    except UnicodeDecodeError:
+        pass
+    try:
+        data.decode("gb18030", errors="strict")
+        return "gb18030"
+    except UnicodeDecodeError:
+        return "utf8"
+
+
+def _python_text_encoding(encoding: str) -> str:
+    if encoding == "utf16le":
+        return "utf-16"
+    if encoding == "utf8-sig":
+        return "utf-8-sig"
+    if encoding == "gb18030":
+        return "gb18030"
     return "utf8"
 
 
 def _write_text_with_encoding(path: Path, content: str, encoding: str) -> None:
-    python_encoding = "utf-16" if encoding == "utf16le" else "utf-8"
-    path.write_text(content, encoding=python_encoding)
+    path.write_text(content, encoding=_python_text_encoding(encoding))
 
 
 def _coerce_write_content(path: Path, content: object) -> tuple[str, dict[str, object], str | None]:
@@ -1976,25 +2055,41 @@ def _build_shell_command(
         platform_name=platform_name,
         os_name=os_name,
     )
+    process_env = _build_shell_process_env(runtime_environment, env)
     if runtime_environment.command_dialect == "powershell":
         return ShellInvocation(
             shell_path=resolved_shell,
             args=_build_powershell_args(command, marker),
             runtime_environment=runtime_environment,
+            env=process_env,
         )
     if runtime_environment.command_dialect == "cmd":
         return ShellInvocation(
             shell_path=resolved_shell,
             args=_build_cmd_args(command, marker),
             runtime_environment=runtime_environment,
+            env=process_env,
         )
     return ShellInvocation(
         shell_path=resolved_shell,
         args=_build_posix_shell_args(command, marker, resolved_shell),
         runtime_environment=runtime_environment,
+        env=process_env,
     )
 
 
+def _build_shell_process_env(
+    runtime_environment: RuntimeEnvironment,
+    env: dict[str, str] | None = None,
+) -> dict[str, str] | None:
+    if runtime_environment.os_family != "windows":
+        return dict(env) if env is not None else None
+    process_env = dict(os.environ if env is None else env)
+    process_env.setdefault("PYTHONUTF8", "1")
+    process_env.setdefault("PYTHONIOENCODING", "utf-8")
+    return process_env
+
+
 def _build_posix_shell_args(command: str, marker: str, shell_path: str) -> list[str]:
     normalized_command = rewrite_windows_null_redirect(command)
     parts = [
@@ -2015,6 +2110,8 @@ def _build_posix_shell_args(command: str, marker: str, shell_path: str) -> list[
 def _build_powershell_args(command: str, marker: str) -> list[str]:
     script = "\n".join(
         [
+            "$OutputEncoding = [System.Text.UTF8Encoding]::new($false)",
+            "[Console]::OutputEncoding = [System.Text.UTF8Encoding]::new($false)",
             "$global:LASTEXITCODE = $null",
             "try {",
             command,

{deepy_cli-0.1.6 → deepy_cli-0.1.8}/src/deepy/ui/message_view.py

@@ -4,8 +4,11 @@ import re
 from dataclasses import dataclass
 from typing import Any
 
+from rich.cells import cell_len
 from rich.console import Group
 from rich.panel import Panel
+from rich.style import Style
+from rich.syntax import Syntax
 from rich.text import Text
 
 from deepy.utils import json as json_utils
@@ -19,6 +22,8 @@ from deepy.ui.styles import (
 MAX_SUMMARY_CHARS = 160
 MAX_THINKING_SUMMARY_CHARS = 360
 MAX_DIFF_LINES = 80
+MAX_SYNTAX_SAMPLE_CHARS = 4_000
+MAX_SYNTAX_SAMPLE_LINES = 80
 DIFF_PREVIEW_TOOLS = {"edit", "write"}
 ROLE_TITLES = {
     "user": "You",
@@ -146,6 +151,7 @@ def render_tool_diff_preview(
     *,
     max_lines: int = MAX_DIFF_LINES,
     palette: UiPalette | None = None,
+    width: int | None = None,
 ) -> Group | None:
     palette = palette or DARK_PALETTE
     view = parse_tool_output(output)
@@ -158,14 +164,11 @@ def render_tool_diff_preview(
     preview = parse_diff_preview_view(diff, path=view.path)
     if not preview.lines:
         return None
-    if view.name.lower() == "write":
-        return Group(
-            render_diff_preview_header(preview, label="Wrote", palette=palette),
-            *(render_write_preview_line(line, palette=palette) for line in preview.lines),
-        )
+    syntax = _diff_preview_syntax(preview, palette)
+    label = "Wrote" if view.name.lower() == "write" else "Edited"
     return Group(
-        render_diff_preview_header(preview, label="Edited", palette=palette),
-        *(render_diff_preview_line(line, palette=palette) for line in preview.lines),
+        render_diff_preview_header(preview, label=label, palette=palette),
+        *(render_diff_preview_line(line, palette=palette, width=width, syntax=syntax) for line in preview.lines),
     )
 
 
@@ -192,20 +195,36 @@ def render_diff_preview_header(
     return Text(f"• {label}", style=f"bold {palette.info}")
 
 
-def render_diff_preview_line(line: DiffPreviewLine, *, palette: UiPalette | None = None) -> Text:
+def render_diff_preview_line(
+    line: DiffPreviewLine,
+    *,
+    palette: UiPalette | None = None,
+    width: int | None = None,
+    syntax: Syntax | None = None,
+) -> Text:
     palette = palette or DARK_PALETTE
     content = line.content if line.content else " "
     old_lineno = _line_number_text(line.old_lineno)
     new_lineno = _line_number_text(line.new_lineno)
     if line.kind == "added":
-        return Text.assemble(
-            (f"{old_lineno} {new_lineno} + ", palette.diff_added_gutter),
-            (content, palette.diff_added),
+        return _pad_changed_diff_line(
+            Text.assemble(
+                (f"{old_lineno} {new_lineno} ", palette.diff_added_gutter),
+                ("+ ", palette.diff_added_marker),
+                _highlight_diff_content(content, syntax=syntax, style=palette.diff_added),
+            ),
+            width=width,
+            style=palette.diff_added,
         )
     if line.kind == "removed":
-        return Text.assemble(
-            (f"{old_lineno} {new_lineno} - ", palette.diff_removed_gutter),
-            (content, palette.diff_removed),
+        return _pad_changed_diff_line(
+            Text.assemble(
+                (f"{old_lineno} {new_lineno} ", palette.diff_removed_gutter),
+                ("- ", palette.diff_removed_marker),
+                _highlight_diff_content(content, syntax=syntax, style=palette.diff_removed),
+            ),
+            width=width,
+            style=palette.diff_removed,
         )
     return Text.assemble(
         (f"{old_lineno} {new_lineno}   ", palette.diff_context),
@@ -213,18 +232,80 @@ def render_diff_preview_line(line: DiffPreviewLine, *, palette: UiPalette | None
     )
 
 
-def render_write_preview_line(line: DiffPreviewLine, *, palette: UiPalette | None = None) -> Text:
-    palette = palette or DARK_PALETTE
-    content = line.content if line.content else " "
-    lineno = line.new_lineno if line.new_lineno is not None else line.old_lineno
-    marker = "-" if line.kind == "removed" else " "
-    gutter_style = palette.diff_removed_gutter if line.kind == "removed" else palette.write_preview_gutter
-    content_style = (
-        palette.write_preview_removed if line.kind == "removed" else palette.write_preview_content
-    )
-    return Text.assemble(
-        (f"{_line_number_text(lineno)} {marker} ", gutter_style),
-        (content, content_style),
+def _pad_changed_diff_line(text: Text, *, width: int | None, style: str) -> Text:
+    if width is None or width <= 0:
+        return text
+    padding = width - cell_len(text.plain)
+    if padding > 0:
+        text.append(" " * padding, style=style)
+    return text
+
+
+def _diff_preview_syntax(preview: DiffPreview, palette: UiPalette) -> Syntax | None:
+    lexer = _guess_diff_preview_lexer(preview)
+    if lexer is None:
+        return None
+    try:
+        return Syntax("", lexer, theme=_diff_syntax_theme(palette), line_numbers=False)
+    except Exception:
+        return None
+
+
+def _guess_diff_preview_lexer(preview: DiffPreview) -> str | None:
+    if not preview.path:
+        return None
+    sample_lines: list[str] = []
+    sample_size = 0
+    for line in preview.lines:
+        if line.kind not in {"added", "removed", "context"} or not line.content.strip():
+            continue
+        sample_lines.append(line.content)
+        sample_size += len(line.content) + 1
+        if len(sample_lines) >= MAX_SYNTAX_SAMPLE_LINES or sample_size >= MAX_SYNTAX_SAMPLE_CHARS:
+            break
+    sample = "\n".join(sample_lines)
+    if not sample.strip():
+        return None
+    try:
+        lexer = Syntax.guess_lexer(preview.path, sample)
+    except Exception:
+        return None
+    return lexer if lexer and lexer != "default" else None
+
+
+def _highlight_diff_content(
+    content: str,
+    *,
+    syntax: Syntax | None,
+    style: str,
+) -> Text:
+    if syntax is None or not content.strip():
+        return Text(content, style=style)
+    try:
+        highlighted = syntax.highlight(content)
+    except Exception:
+        return Text(content, style=style)
+
+    base = Style.parse(style)
+    text = Text(content, style=base)
+    for span in highlighted.spans:
+        text.stylize(_syntax_style_on_diff_background(span.style, base), span.start, span.end)
+    return text
+
+
+def _diff_syntax_theme(palette: UiPalette) -> str:
+    return "default" if palette.name == "light" else "monokai"
+
+
+def _syntax_style_on_diff_background(style: Style, base: Style) -> Style:
+    return Style(
+        color=style.color or base.color,
+        bgcolor=base.bgcolor,
+        bold=style.bold,
+        italic=style.italic,
+        underline=style.underline,
+        dim=style.dim,
+        strike=style.strike,
     )
 
 
@@ -342,11 +423,16 @@ def is_invisible_execution(content: str) -> bool:
     return isinstance(parsed, dict) and parsed.get("name") == "shell" and parsed.get("ok") is not True
 
 
-def render_tool_output(output: str, *, palette: UiPalette | None = None) -> Group:
+def render_tool_output(
+    output: str,
+    *,
+    palette: UiPalette | None = None,
+    width: int | None = None,
+) -> Group:
     palette = palette or DARK_PALETTE
     view = parse_tool_output(output)
     parts: list[Any] = [Text(view.summary, style=status_style(view.ok, palette))]
-    diff = render_tool_diff_preview(output, palette=palette)
+    diff = render_tool_diff_preview(output, palette=palette, width=width)
     if diff:
         parts.append(diff)
     return Group(*parts)
@@ -357,12 +443,13 @@ def render_message(
     *,
     project_root: str | None = None,
     palette: UiPalette | None = None,
+    width: int | None = None,
 ) -> Any:
     palette = palette or DARK_PALETTE
     role = _string_or_default(message.get("role"), "message")
     content = _message_content_text(message.get("content"))
     if role == "tool":
-        return render_tool_output(content, palette=palette)
+        return render_tool_output(content, palette=palette, width=width)
 
     title = ROLE_TITLES.get(role, role.title())
     if role == "assistant":

{deepy_cli-0.1.6 → deepy_cli-0.1.8}/src/deepy/ui/prompt_input.py

@@ -2,6 +2,7 @@ from __future__ import annotations
 
 from dataclasses import dataclass
 from pathlib import Path
+import sys
 from typing import Callable
 from unicodedata import normalize
 
@@ -32,6 +33,7 @@ SHIFT_ENTER_SEQUENCES = (
     "\x1b[27;2;13~",  # xterm modified-key format.
     "\x1b[13;2u",  # Kitty/fixterms CSI-u format, used by modern terminals.
 )
+_WINDOWS_SHIFT_ENTER_PATCH_ATTR = "_deepy_shift_enter_patched"
 
 
 @dataclass(frozen=True)
@@ -102,6 +104,60 @@ def install_shift_enter_key_sequence_overrides() -> None:
     prefix_cache = getattr(vt100_parser, "_IS_PREFIX_OF_LONGER_MATCH_CACHE", None)
     if hasattr(prefix_cache, "clear"):
         prefix_cache.clear()
+    install_windows_shift_enter_key_sequence_override()
+
+
+def install_windows_shift_enter_key_sequence_override(
+    *,
+    platform_name: str | None = None,
+    console_input_reader_cls: type | None = None,
+) -> bool:
+    resolved_platform = platform_name or sys.platform
+    if not resolved_platform.startswith("win"):
+        return False
+    if console_input_reader_cls is None:
+        try:
+            from prompt_toolkit.input import win32
+        except (AssertionError, ImportError):
+            return False
+        console_input_reader_cls = win32.ConsoleInputReader
+    if getattr(console_input_reader_cls, _WINDOWS_SHIFT_ENTER_PATCH_ATTR, False):
+        return True
+
+    from prompt_toolkit.key_binding.key_processor import KeyPress
+
+    original_handler = console_input_reader_cls._event_to_key_presses
+    shift_pressed = getattr(console_input_reader_cls, "SHIFT_PRESSED", 0x0010)
+
+    def patched_event_to_key_presses(self, ev):
+        key_presses = original_handler(self, ev)
+        if _is_windows_shift_enter_key_press(ev, key_presses, shift_pressed=shift_pressed):
+            return [KeyPress(Keys.Escape, ""), key_presses[0]]
+        return key_presses
+
+    setattr(
+        console_input_reader_cls,
+        "_deepy_original_event_to_key_presses",
+        original_handler,
+    )
+    console_input_reader_cls._event_to_key_presses = patched_event_to_key_presses
+    setattr(console_input_reader_cls, _WINDOWS_SHIFT_ENTER_PATCH_ATTR, True)
+    return True
+
+
+def _is_windows_shift_enter_key_press(
+    ev,
+    key_presses: list,
+    *,
+    shift_pressed: int,
+) -> bool:
+    if not key_presses or len(key_presses) != 1:
+        return False
+    control_key_state = getattr(ev, "ControlKeyState", 0)
+    if not control_key_state & shift_pressed:
+        return False
+    key = getattr(key_presses[0], "key", None)
+    return key in {Keys.ControlM, Keys.ControlJ, Keys.Enter}
 
 
 def prompt_for_input(

{deepy_cli-0.1.6 → deepy_cli-0.1.8}/src/deepy/ui/styles.py

@@ -32,12 +32,11 @@ class UiPalette:
     panel_border: str
     diff_added: str
     diff_added_gutter: str
+    diff_added_marker: str
     diff_removed: str
     diff_removed_gutter: str
+    diff_removed_marker: str
     diff_context: str
-    write_preview_gutter: str
-    write_preview_content: str
-    write_preview_removed: str
     prompt: str
     placeholder: str
     toolbar_background: str
@@ -69,14 +68,13 @@ DARK_PALETTE = UiPalette(
     system=STYLE_SYSTEM,
     tool=STYLE_TOOL,
     panel_border=STYLE_INFO,
-    diff_added="#e5e7eb on #14532d",
-    diff_added_gutter="#cbd5e1 on #14532d",
-    diff_removed="#e5e7eb on #7f1d1d",
-    diff_removed_gutter="#cbd5e1 on #7f1d1d",
+    diff_added="#e5e7eb on #1f3d2b",
+    diff_added_gutter="#cbd5e1 on #1f3d2b",
+    diff_added_marker="bold #86efac on #1f3d2b",
+    diff_removed="#e5e7eb on #4a2528",
+    diff_removed_gutter="#cbd5e1 on #4a2528",
+    diff_removed_marker="bold #fca5a5 on #4a2528",
     diff_context=STYLE_MUTED,
-    write_preview_gutter="#94a3b8 on #1f2937",
-    write_preview_content="#d7def8 on #1f2937",
-    write_preview_removed="#fecaca on #7f1d1d",
     prompt="ansicyan bold",
     placeholder="#8a90aa",
     toolbar_background="#161821",
@@ -108,14 +106,13 @@ LIGHT_PALETTE = UiPalette(
     system="#7e22ce",
     tool="#92400e",
     panel_border="#2563eb",
-    diff_added="#064e3b on #dcfce7",
-    diff_added_gutter="#065f46 on #bbf7d0",
-    diff_removed="#7f1d1d on #fee2e2",
-    diff_removed_gutter="#991b1b on #fecaca",
+    diff_added="#064e3b on #ecfdf5",
+    diff_added_gutter="#065f46 on #d1fae5",
+    diff_added_marker="bold #047857 on #d1fae5",
+    diff_removed="#7f1d1d on #fef2f2",
+    diff_removed_gutter="#991b1b on #fee2e2",
+    diff_removed_marker="bold #b91c1c on #fee2e2",
     diff_context="#374151",
-    write_preview_gutter="#475569 on #e2e8f0",
-    write_preview_content="#111827 on #f8fafc",
-    write_preview_removed="#7f1d1d on #fee2e2",
     prompt="#0369a1 bold",
     placeholder="#64748b",
     toolbar_background="#e2e8f0",

{deepy_cli-0.1.6 → deepy_cli-0.1.8}/src/deepy/ui/terminal.py

@@ -1328,7 +1328,7 @@ def _format_context_footer(
         return " · ".join(parts)
 
     session_entry = _session_entry(project_root, session_id)
-    used_tokens = session_entry.active_tokens if session_entry is not None else (0 if not session_id else None)
+    used_tokens = _session_context_tokens(project_root, session_id, session_entry)
     used_text = _format_token_count_short(used_tokens) if used_tokens is not None else "unknown"
     used_ratio = (
         f" ({used_tokens / window_tokens * 100:.1f}%)"
@@ -1372,6 +1372,25 @@ def _session_entry(project_root: Path | None, session_id: str | None) -> Session
     return entry
 
 
+def _session_context_tokens(
+    project_root: Path | None,
+    session_id: str | None,
+    session_entry: SessionEntry | None,
+) -> int | None:
+    if not session_id:
+        return 0
+    if project_root is not None:
+        try:
+            session = DeepyJsonlSession.open(project_root, session_id)
+            if session.path.exists():
+                return session.context_token_state().active_tokens
+        except Exception:
+            pass
+    if session_entry is not None:
+        return session_entry.active_tokens
+    return None
+
+
 def _format_token_count_short(value: int) -> str:
     if value < 1_000:
         return str(value)
@@ -1500,7 +1519,7 @@ def _print_stream_event(
         call_summary = call.summary if call is not None else view.name
         summary = format_tool_progress_summary(call_summary, event.text)
         console.print(_status_line(summary, status_style(view.ok, palette)))
-        diff = render_tool_diff_preview(event.text, palette=palette)
+        diff = render_tool_diff_preview(event.text, palette=palette, width=console.width)
         if diff:
             console.print(diff)
         return