pythinker-code 0.9.0__tar.gz → 0.10.0__tar.gz

{pythinker_code-0.9.0 → pythinker_code-0.10.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: pythinker-code
-Version: 0.9.0
+Version: 0.10.0
 Summary: Pythinker Code is your next CLI agent.
 Keywords: cli,agent,ai,coding-assistant,llm,claude,openai,terminal
 Author: Mohamed Elkholy
@@ -115,16 +115,17 @@ It speaks the [**Agent Client Protocol (ACP)**](https://github.com/agentclientpr
 
 ---
 
-## 🆕 What's New in 0.9.0
+## 🆕 What's New in 0.10.0
 
-- **Cleaner TUI — tool card backgrounds removed.** The grey pending/running overlay behind tool execution cards (subagents, bash, reads, etc.) is gone. Only user-message blocks keep a background tint, keeping visual focus on your input.
-- **Welcome screen enhancements.** The startup panel now shows the current git branch (highlighted in magenta) and the session auto-save path alongside the working directory and session ID.
-- **Bash header strip styling.** The `$ command` strip in bash execution headers now uses the `tool_pending_bg` theme token, matching the reference renderer across light and dark themes.
-- **Pythinker markdown renderer in all messages.** User, assistant, and custom messages now render through `pythinker_markdown` for consistent heading, code-block, and table styling.
-- **Expanded theme palette.** A new `MarkdownColors` / `markdown_rich_style` subsystem in `theme.py` covers headings, emphasis, inline code, links, blockquotes, table borders, code-block backgrounds, and spinner states with separate dark and light palettes.
-- **Improved tool fallback renderers.** Call fallbacks now show a status glyph (`✔`/`✘`/`●`); result fallbacks truncate at 60 lines / 4000 chars with an italicised note and use correct theme tokens.
+- **Tool failure recovery improvements.** The agent loop now handles malformed or empty tool-call responses more gracefully and can continue the session instead of leaving the UI stuck after a bad provider turn.
+- **Safer file edits.** File write and replace tools now create restore points before mutating files, giving sessions a clearer recovery path after risky changes.
+- **Session UX state tracking.** Runtime session state now records additional UX metadata so shell surfaces can provide better continuity across long-running work.
+- **Shell command enhancements.** New shell slash-command plumbing improves discoverability and keeps interactive workflows smoother.
+- **TUI renderer polish.** Tool cards now share more consistent status glyphs, truncation behavior, and result summaries across bash, read, write, edit, grep, find, web, subagent, background, ask-user, and think renderers.
+- **Clipboard handling hardening.** Clipboard helpers now degrade more cleanly when platform clipboard access is unavailable.
+- **Release and TUI specs.** The repository now includes the blackbox TUI port design and a visual smoke-test criterion for future terminal UI work.
 
-Upgrade with `pythinker update` or `pip install --upgrade pythinker-code==0.9.0`.
+Upgrade with `pythinker update` or `pip install --upgrade pythinker-code==0.10.0`.
 
 
 ---

{pythinker_code-0.9.0 → pythinker_code-0.10.0}/README.md

@@ -50,16 +50,17 @@ It speaks the [**Agent Client Protocol (ACP)**](https://github.com/agentclientpr
 
 ---
 
-## 🆕 What's New in 0.9.0
+## 🆕 What's New in 0.10.0
 
-- **Cleaner TUI — tool card backgrounds removed.** The grey pending/running overlay behind tool execution cards (subagents, bash, reads, etc.) is gone. Only user-message blocks keep a background tint, keeping visual focus on your input.
-- **Welcome screen enhancements.** The startup panel now shows the current git branch (highlighted in magenta) and the session auto-save path alongside the working directory and session ID.
-- **Bash header strip styling.** The `$ command` strip in bash execution headers now uses the `tool_pending_bg` theme token, matching the reference renderer across light and dark themes.
-- **Pythinker markdown renderer in all messages.** User, assistant, and custom messages now render through `pythinker_markdown` for consistent heading, code-block, and table styling.
-- **Expanded theme palette.** A new `MarkdownColors` / `markdown_rich_style` subsystem in `theme.py` covers headings, emphasis, inline code, links, blockquotes, table borders, code-block backgrounds, and spinner states with separate dark and light palettes.
-- **Improved tool fallback renderers.** Call fallbacks now show a status glyph (`✔`/`✘`/`●`); result fallbacks truncate at 60 lines / 4000 chars with an italicised note and use correct theme tokens.
+- **Tool failure recovery improvements.** The agent loop now handles malformed or empty tool-call responses more gracefully and can continue the session instead of leaving the UI stuck after a bad provider turn.
+- **Safer file edits.** File write and replace tools now create restore points before mutating files, giving sessions a clearer recovery path after risky changes.
+- **Session UX state tracking.** Runtime session state now records additional UX metadata so shell surfaces can provide better continuity across long-running work.
+- **Shell command enhancements.** New shell slash-command plumbing improves discoverability and keeps interactive workflows smoother.
+- **TUI renderer polish.** Tool cards now share more consistent status glyphs, truncation behavior, and result summaries across bash, read, write, edit, grep, find, web, subagent, background, ask-user, and think renderers.
+- **Clipboard handling hardening.** Clipboard helpers now degrade more cleanly when platform clipboard access is unavailable.
+- **Release and TUI specs.** The repository now includes the blackbox TUI port design and a visual smoke-test criterion for future terminal UI work.
 
-Upgrade with `pythinker update` or `pip install --upgrade pythinker-code==0.9.0`.
+Upgrade with `pythinker update` or `pip install --upgrade pythinker-code==0.10.0`.
 
 
 ---

{pythinker_code-0.9.0 → pythinker_code-0.10.0}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "pythinker-code"
-version = "0.9.0"
+version = "0.10.0"
 description = "Pythinker Code is your next CLI agent."
 readme = "README.md"
 requires-python = ">=3.12"

{pythinker_code-0.9.0 → pythinker_code-0.10.0}/src/pythinker_code/CHANGELOG.md

@@ -15,6 +15,20 @@ GitHub Releases page; `0.8.0` is the new starting line.
 
 ## Unreleased
 
+## 0.10.0 (2026-05-22)
+
+### What changed in this release
+
+- **Tool failure recovery improvements.** The agent loop now handles malformed or empty tool-call responses more gracefully and can continue the session instead of leaving the UI stuck after a bad provider turn.
+- **Safer file edits.** File write and replace tools now create restore points before mutating files, giving sessions a clearer recovery path after risky changes.
+- **Session UX state tracking.** Runtime session state now records additional UX metadata so shell surfaces can provide better continuity across long-running work.
+- **Shell command enhancements.** New shell slash-command plumbing improves discoverability and keeps interactive workflows smoother.
+- **TUI renderer polish.** Tool cards now share more consistent status glyphs, truncation behavior, and result summaries across bash, read, write, edit, grep, find, web, subagent, background, ask-user, and think renderers.
+- **Clipboard handling hardening.** Clipboard helpers now degrade more cleanly when platform clipboard access is unavailable.
+- **Release and TUI specs.** The repository now includes the blackbox TUI port design and a visual smoke-test criterion for future terminal UI work.
+
+Upgrade with `pythinker update` or `pip install --upgrade pythinker-code==0.10.0`.
+
 ## 0.9.0 (2026-05-21)
 
 ### What changed in this release

{pythinker_code-0.9.0 → pythinker_code-0.10.0}/src/pythinker_code/app.py

@@ -41,7 +41,7 @@ if TYPE_CHECKING:
 _CWD_LOCK = asyncio.Lock()
 
 
-def _safe_git_branch(cwd: str | Path) -> str | None:
+def _safe_git_branch(cwd: str | Path | HostPath) -> str | None:
     """Return the current git branch name, or ``None`` outside a repo / on error."""
     import subprocess
 
@@ -49,6 +49,7 @@ def _safe_git_branch(cwd: str | Path) -> str | None:
         result = subprocess.run(
             ["git", "-C", str(cwd), "branch", "--show-current"],
             capture_output=True,
+            encoding="utf-8",
             text=True,
             timeout=1.0,
             check=False,
@@ -752,7 +753,9 @@ class PythinkerCLI:
             welcome_info.append(WelcomeInfoItem(name="Branch", value=branch_name))
         welcome_info.append(WelcomeInfoItem(name="Session", value=self._runtime.session.id))
         try:
-            auto_save_path = str(shorten_home(self._runtime.session.context_file))
+            auto_save_path = str(
+                shorten_home(HostPath.unsafe_from_local_path(self._runtime.session.context_file))
+            )
         except Exception:
             auto_save_path = ""
         if auto_save_path:

pythinker_code-0.10.0/src/pythinker_code/file_restore.py

@@ -0,0 +1,83 @@
+from __future__ import annotations
+
+import base64
+import time
+import uuid
+from pathlib import Path
+
+from pydantic import BaseModel
+
+from pythinker_code.session import Session
+from pythinker_code.utils.io import atomic_json_write
+
+_RESTORE_DIR = "file_restore_points"
+
+
+class FileRestorePoint(BaseModel):
+    id: str
+    created_at: float
+    tool_name: str
+    path: Path
+    existed: bool
+    content_b64: str | None = None
+
+
+def _restore_dir(session: Session) -> Path:
+    path = session.dir / _RESTORE_DIR
+    path.mkdir(parents=True, exist_ok=True)
+    return path
+
+
+def _restore_file(session: Session, restore_id: str) -> Path:
+    return _restore_dir(session) / f"{restore_id}.json"
+
+
+def create_file_restore_point(
+    session: Session,
+    *,
+    tool_name: str,
+    path: str | Path,
+) -> FileRestorePoint:
+    target = Path(path)
+    existed = target.exists()
+    content_b64 = None
+    if existed and target.is_file():
+        content_b64 = base64.b64encode(target.read_bytes()).decode("utf-8")
+
+    point = FileRestorePoint(
+        id=f"{int(time.time() * 1000)}-{uuid.uuid4().hex[:8]}",
+        created_at=time.time(),
+        tool_name=tool_name,
+        path=target,
+        existed=existed,
+        content_b64=content_b64,
+    )
+    atomic_json_write(point.model_dump(mode="json"), _restore_file(session, point.id))
+    return point
+
+
+def list_file_restore_points(
+    session: Session, *, limit: int | None = None
+) -> list[FileRestorePoint]:
+    points: list[FileRestorePoint] = []
+    for path in _restore_dir(session).glob("*.json"):
+        try:
+            points.append(FileRestorePoint.model_validate_json(path.read_text(encoding="utf-8")))
+        except Exception:
+            continue
+    points.sort(key=lambda point: (point.created_at, point.id), reverse=True)
+    return points[:limit] if limit is not None else points
+
+
+def restore_file_restore_point(session: Session, restore_id: str) -> FileRestorePoint:
+    point = FileRestorePoint.model_validate_json(
+        _restore_file(session, restore_id).read_text(encoding="utf-8")
+    )
+    if not point.existed:
+        point.path.unlink(missing_ok=True)
+        return point
+
+    point.path.parent.mkdir(parents=True, exist_ok=True)
+    content = base64.b64decode(point.content_b64 or "")
+    point.path.write_bytes(content)
+    return point

{pythinker_code-0.9.0 → pythinker_code-0.10.0}/src/pythinker_code/session_state.py

@@ -18,6 +18,17 @@ class ApprovalStateData(BaseModel):
     auto_approve_actions: set[str] = Field(default_factory=set)
 
 
+class TrustStateData(BaseModel):
+    trusted: bool = False
+    safe_mode: bool = True
+
+
+class AccessibilityStateData(BaseModel):
+    plain_output: bool = False
+    animations: bool = True
+    symbols: Literal["unicode", "ascii"] = "unicode"
+
+
 class TodoItemState(BaseModel):
     """A single todo item stored in session or subagent state."""
 
@@ -28,6 +39,8 @@ class TodoItemState(BaseModel):
 class SessionState(BaseModel):
     version: int = 1
     approval: ApprovalStateData = Field(default_factory=ApprovalStateData)
+    trust: TrustStateData = Field(default_factory=TrustStateData)
+    accessibility: AccessibilityStateData = Field(default_factory=AccessibilityStateData)
     additional_dirs: list[str] = Field(default_factory=list)
     custom_title: str | None = None
     title_generated: bool = False

{pythinker_code-0.9.0 → pythinker_code-0.10.0}/src/pythinker_code/soul/agent.py

@@ -288,6 +288,9 @@ class Runtime:
 
         # Merge invocation flags with persisted session state.
         effective_yolo = yolo or session.state.approval.yolo
+        # An explicit --yolo invocation is already a deliberate trust decision for
+        # this run, so it must not deadlock non-interactive/e2e flows behind safe mode.
+        effective_safe_mode = False if yolo else session.state.trust.safe_mode
         if auto and not session.state.approval.auto:
             session.state.approval.auto = True
             session.save_state()
@@ -297,12 +300,14 @@ class Runtime:
             session.state.approval.yolo = approval_state.yolo
             session.state.approval.auto = approval_state.auto
             session.state.approval.auto_approve_actions = set(approval_state.auto_approve_actions)
+            session.state.trust.safe_mode = approval_state.safe_mode
             session.save_state()
 
         approval_state = ApprovalState(
             yolo=effective_yolo,
             auto=session.state.approval.auto,
             runtime_auto=runtime_auto,
+            safe_mode=effective_safe_mode,
             auto_approve_actions=saved_actions,
             on_change=_on_approval_change,
         )

{pythinker_code-0.9.0 → pythinker_code-0.10.0}/src/pythinker_code/soul/approval.py

@@ -58,6 +58,7 @@ class ApprovalState:
         yolo: bool = False,
         auto: bool = False,
         runtime_auto: bool = False,
+        safe_mode: bool = False,
         auto_approve_actions: set[str] | None = None,
         on_change: Callable[[], None] | None = None,
     ):
@@ -69,6 +70,8 @@ class ApprovalState:
         """
         self.runtime_auto = runtime_auto
         """Invocation-only auto flag, e.g. ``--auto`` or ``--print``. Not persisted."""
+        self.safe_mode = safe_mode
+        """When true, all auto-approval paths are suppressed."""
         self.auto_approve_actions: set[str] = auto_approve_actions or set()
         """Set of action names that should automatically be approved."""
         self._on_change = on_change
@@ -120,12 +123,18 @@ class Approval:
         """Toggle invocation-only auto mode without persisting it."""
         self._state.runtime_auto = auto
 
+    def set_safe_mode(self, safe_mode: bool) -> None:
+        self._state.safe_mode = safe_mode
+        self._state.notify_change()
+
     def is_auto_approve(self) -> bool:
         """True when tool calls should be auto-approved.
 
         Auto mode implies auto-approve, so this returns True whenever either the
         explicit yolo flag or auto mode is set.
         """
+        if self._state.safe_mode:
+            return False
         return self._state.yolo or self.is_auto()
 
     def is_yolo(self) -> bool:

{pythinker_code-0.9.0 → pythinker_code-0.10.0}/src/pythinker_code/soul/pythinkersoul.py

@@ -2,6 +2,7 @@ from __future__ import annotations
 
 import asyncio
 import contextlib
+import re
 import time
 import uuid
 from collections.abc import Awaitable, Callable, Sequence
@@ -20,7 +21,7 @@ from pythinker_core.chat_provider import (
     APITimeoutError,
     RetryableChatProvider,
 )
-from pythinker_core.message import Message
+from pythinker_core.message import Message, ToolCall
 from tenacity import RetryCallState, retry_if_exception, stop_after_attempt, wait_exponential_jitter
 
 from pythinker_code.approval_runtime import (
@@ -166,6 +167,54 @@ def classify_api_error(e: Exception) -> tuple[str, int | None]:
 type StepStopReason = Literal["no_tool_calls", "tool_rejected"]
 
 
+_MISSING_REQUIRED_FIELD_RE = re.compile(
+    r"^\s*(?P<field>[A-Za-z_][A-Za-z0-9_\-.]*)\s*\n\s+Field required",
+    re.MULTILINE,
+)
+
+
+def _missing_required_fields_from_validation_error(message: str) -> list[str]:
+    """Extract field names from Pydantic's missing-field validation text."""
+    if "Error validating JSON arguments:" not in message:
+        return []
+    return [match.group("field") for match in _MISSING_REQUIRED_FIELD_RE.finditer(message)]
+
+
+def _is_empty_tool_arguments(tool_call: ToolCall) -> bool:
+    raw = tool_call.function.arguments
+    return raw is None or raw.strip() in {"", "{}"}
+
+
+def _malformed_empty_tool_call_summary(
+    tool_calls: Sequence[ToolCall], tool_results: Sequence[ToolResult]
+) -> str | None:
+    """Return a concise summary when a step only produced empty invalid tool calls.
+
+    Some models can get stuck emitting `{}`/empty arguments for tools with required
+    fields. Continuing the agent loop just floods the UI with repeated validation
+    cards. Detect that dead-end shape and stop after the first invalid batch.
+    """
+    if not tool_calls or len(tool_calls) != len(tool_results):
+        return None
+
+    calls_by_id = {call.id: call for call in tool_calls}
+    missing_by_tool: list[str] = []
+    for result in tool_results:
+        call = calls_by_id.get(result.tool_call_id)
+        if call is None or not _is_empty_tool_arguments(call):
+            return None
+        if not result.return_value.is_error:
+            return None
+        fields = _missing_required_fields_from_validation_error(result.return_value.message)
+        if not fields:
+            return None
+        missing_by_tool.append(f"{call.function.name}.{', '.join(fields)}")
+
+    if not missing_by_tool:
+        return None
+    return "; ".join(missing_by_tool)
+
+
 @dataclass(frozen=True, slots=True)
 class StepOutcome:
     stop_reason: StepStopReason
@@ -1249,6 +1298,23 @@ class PythinkerSoul:
             await asyncio.shield(grow_context_task)
             raise
 
+        if invalid_summary := _malformed_empty_tool_call_summary(result.tool_calls, results):
+            message = Message(
+                role="assistant",
+                content=[
+                    TextPart(
+                        text=(
+                            "I couldn't continue because the model emitted malformed empty "
+                            "tool calls with missing required arguments: "
+                            f"{invalid_summary}. Please retry the request, or switch models "
+                            "if this repeats."
+                        )
+                    )
+                ],
+            )
+            await self._context.append_message(message)
+            return StepOutcome(stop_reason="no_tool_calls", assistant_message=message)
+
         rejected_errors = [
             result.return_value
             for result in results

{pythinker_code-0.9.0 → pythinker_code-0.10.0}/src/pythinker_code/tools/file/replace.py

@@ -6,6 +6,7 @@ from pydantic import BaseModel, Field
 from pythinker_core.tooling import CallableTool2, ToolError, ToolReturnValue
 from pythinker_host.path import HostPath
 
+from pythinker_code.file_restore import create_file_restore_point
 from pythinker_code.soul.agent import Runtime
 from pythinker_code.soul.approval import Approval
 from pythinker_code.soul.permission import check_file_mutation_allowed
@@ -172,6 +173,8 @@ class StrReplaceFile(CallableTool2[Params]):
                 if not result:
                     return result.rejection_error()
 
+            create_file_restore_point(self._runtime.session, tool_name=self.name, path=str(p))
+
             # Write the modified content back to the file
             await p.write_text(content, encoding="utf-8", errors="replace")
 

{pythinker_code-0.9.0 → pythinker_code-0.10.0}/src/pythinker_code/tools/file/write.py

@@ -6,6 +6,7 @@ from pydantic import BaseModel, Field
 from pythinker_core.tooling import CallableTool2, ToolError, ToolReturnValue
 from pythinker_host.path import HostPath
 
+from pythinker_code.file_restore import create_file_restore_point
 from pythinker_code.soul.agent import Runtime
 from pythinker_code.soul.approval import Approval
 from pythinker_code.soul.permission import check_file_mutation_allowed
@@ -158,6 +159,8 @@ class WriteFile(CallableTool2[Params]):
                 if not result:
                     return result.rejection_error()
 
+            create_file_restore_point(self._runtime.session, tool_name=self.name, path=str(p))
+
             # Write content to file
             match params.mode:
                 case "overwrite":

{pythinker_code-0.9.0 → pythinker_code-0.10.0}/src/pythinker_code/ui/shell/components/bash_execution.py

@@ -134,7 +134,6 @@ def format_bash_command_for_header(command: str, *, expanded: bool) -> str:
 
 
 def _status_header(state: BashExecutionState) -> Text:
-    accent = _accent_style(state)
     if state.status in ("pending", "running"):
         header = _pulsing_marker()
         header.append("Running", style=tui_rich_style("muted") + RichStyle(bold=True))

{pythinker_code-0.9.0 → pythinker_code-0.10.0}/src/pythinker_code/ui/shell/components/markdown.py

@@ -18,13 +18,14 @@ from __future__ import annotations
 
 from dataclasses import dataclass, field
 
-from rich.console import Console, ConsoleOptions, Group, RenderResult, RenderableType
+from rich.console import Console, ConsoleOptions, RenderableType, RenderResult
 from rich.markdown import CodeBlock, Markdown
 from rich.padding import Padding
 from rich.rule import Rule
 from rich.style import Style as RichStyle
 from rich.syntax import Syntax
 from rich.text import Text
+from rich.theme import Theme
 
 from pythinker_code.ui.theme import ThemeName, get_markdown_colors
 
@@ -38,9 +39,7 @@ __all__ = [
 class _BorderedCodeBlock(CodeBlock):
     """Code block with ``╭─ lang`` / ``╰─`` border rules and background tint."""
 
-    def __rich_console__(
-        self, console: Console, options: ConsoleOptions
-    ) -> RenderResult:
+    def __rich_console__(self, console: Console, options: ConsoleOptions) -> RenderResult:
         colors = get_markdown_colors()
         border_style = RichStyle(color=colors.code_block_border, bold=True)
         bg_style = RichStyle(bgcolor=colors.code_block_bg) if colors.code_block_bg else RichStyle()
@@ -96,26 +95,12 @@ class PythinkerMarkdown(Markdown):
 
     elements = {**Markdown.elements, "fence": _BorderedCodeBlock, "code_block": _BorderedCodeBlock}
 
-    def __rich_console__(
-        self, console: Console, options: ConsoleOptions
-    ) -> RenderResult:
+    def __rich_console__(self, console: Console, options: ConsoleOptions) -> RenderResult:
         overrides = _markdown_style_overrides()
-        with console.use_theme(_PythinkerMarkdownTheme(overrides)):
+        with console.use_theme(Theme(overrides, inherit=True)):
             yield from super().__rich_console__(console, options)
 
 
-class _PythinkerMarkdownTheme:
-    """Lightweight Rich ``Theme`` shim — only enough to satisfy ``Console.use_theme``."""
-
-    def __init__(self, styles: dict[str, RichStyle]) -> None:
-        from rich.theme import Theme
-
-        self._theme = Theme(styles, inherit=True)
-
-    def __getattr__(self, name: str):  # type: ignore[no-untyped-def]
-        return getattr(self._theme, name)
-
-
 def pythinker_markdown(text: str, *, code_theme: str = "monokai") -> PythinkerMarkdown:
     """Build a :class:`PythinkerMarkdown` with the palette pre-wired."""
     return PythinkerMarkdown(text, code_theme=code_theme)
@@ -199,9 +184,7 @@ def _find_stream_safe_boundary(text: str) -> int | None:
             open_fence = opener
             cursor = line_end
             continue
-        if not content.strip():
-            last_boundary = line_end
-        elif content.rstrip().endswith(_SENTENCE_END):
+        if not content.strip() or content.rstrip().endswith(_SENTENCE_END):
             last_boundary = line_end
         cursor = line_end
     return last_boundary

{pythinker_code-0.9.0 → pythinker_code-0.10.0}/src/pythinker_code/ui/shell/components/tool_execution.py

@@ -235,6 +235,10 @@ class ToolExecutionComponent:
         return None
 
     def _background_style(self) -> Style | None:
+        if self._status in _PENDING_LIKE:
+            return tui_rich_style("tool_pending_bg")
+        if self._status in (ToolExecutionStatus.ERROR, ToolExecutionStatus.DENIED):
+            return tui_rich_style("tool_error_bg")
         return None
 
     def _call_fallback(self) -> RenderableType: