mlx-code 0.0.12__tar.gz → 0.0.14__tar.gz

{mlx_code-0.0.12 → mlx_code-0.0.14}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: mlx-code
-Version: 0.0.12
+Version: 0.0.14
 Summary: Coding Agent for Mac
 Home-page: https://josefalbers.github.io/mlx-code/
 Author: J Joe

{mlx_code-0.0.12 → mlx_code-0.0.14}/mlx_code/gits.py

@@ -63,7 +63,7 @@ def create_worktree(repo_dir: str, *, worktree_dir: str | None=None, ref: str='H
             root = repo_dir
             gi = os.path.join(root, '.gitignore')
             if not os.path.exists(gi):
-                Path(gi).write_text('\n'.join(['__pycache__/', '*.pyc', '.DS_Store', '*.bin', '*.safetensors', '*.gguf', '*.pt', '*.pth', '.cache/', '_*']))
+                Path(gi).write_text('\n'.join(['_log.json']))
         if not _git(root, 'config', 'user.email', check=False):
             _git(root, 'config', 'user.email', 'agent@local')
         if not _git(root, 'config', 'user.name', check=False):
@@ -177,4 +177,53 @@ def current_point(worktree_dir: str) -> LedgerPoint:
     worktree_dir = os.path.abspath(worktree_dir)
     branch = _git(worktree_dir, 'symbolic-ref', '--short', 'HEAD', check=False) or 'DETACHED'
     sha = _git(worktree_dir, 'rev-parse', 'HEAD', check=False)
-    return LedgerPoint(branch=branch, commit=sha, worktree=worktree_dir)
+    return LedgerPoint(branch=branch, commit=sha, worktree=worktree_dir)
+
+def get_commit_history_with_stats(worktree: str, limit: int=50) -> list[dict]:
+    try:
+        cmd = ['git', 'log', '--name-status', '--format=COMMIT:%H%nSHORT:%h%nREFS:%d%nSUBJECT:%s%nBODY_START%n%b%nBODY_END', f'-n{limit}']
+        result = subprocess.run(cmd, cwd=worktree, capture_output=True, text=True, check=True)
+        output = result.stdout.strip()
+        commits = []
+        current_commit = None
+        in_body = False
+        body_lines = []
+        for line in output.split('\n'):
+            if line.startswith('COMMIT:'):
+                if current_commit:
+                    body_text = '\n'.join(body_lines)
+                    current_commit['user_turns'] = body_text.count('"role": "user"')
+                    commits.append(current_commit)
+                current_commit = {'sha': line[7:], 'short_sha': '', 'refs': '', 'subject': '', 'files': []}
+                in_body = False
+                body_lines = []
+            elif line.startswith('SHORT:'):
+                if current_commit:
+                    current_commit['short_sha'] = line[6:]
+            elif line.startswith('REFS:'):
+                if current_commit:
+                    current_commit['refs'] = line[5:].strip()
+            elif line.startswith('SUBJECT:'):
+                if current_commit:
+                    current_commit['subject'] = line[8:]
+            elif line == 'BODY_START':
+                in_body = True
+            elif line == 'BODY_END':
+                in_body = False
+            elif current_commit:
+                if in_body:
+                    body_lines.append(line)
+                elif line.strip():
+                    parts = line.split('\t', 1)
+                    if len(parts) == 2:
+                        current_commit['files'].append(f'{parts[0]} {parts[1]}')
+                    else:
+                        current_commit['files'].append(line)
+        if current_commit:
+            body_text = '\n'.join(body_lines)
+            current_commit['user_turns'] = body_text.count('"role": "user"')
+            commits.append(current_commit)
+        return commits
+    except Exception as e:
+        logger.warning(f'get_commit_history_with_stats failed: {e}')
+        return []

{mlx_code-0.0.12 → mlx_code-0.0.14}/mlx_code/repl.py

@@ -1,35 +1,30 @@
 from __future__ import annotations
 import asyncio
-import argparse
 import datetime
 import json
 import os
 import pathlib
 import re
-import shutil
 import socket
 import sys
 import tempfile
 import time
 import logging
 import urllib.parse
-from dataclasses import dataclass, field
 from typing import Any, Callable, Literal
-from .gits import create_worktree, commit_worktree, resume_worktree, cleanup_worktree, git_new_branch, git_switch_branch, GitError
+from .gits import create_worktree, commit_worktree, resume_worktree, cleanup_worktree, git_new_branch, git_switch_branch, GitError, get_commit_history_with_stats
 from .tools import Tool, validate_tool_call, DEFAULT_TOOLS
 from .apis import resolve_api
 logger = logging.getLogger(__name__)
 from textual.app import App, ComposeResult
 from textual.binding import Binding
-from textual.containers import VerticalScroll
+from textual.containers import VerticalScroll, Vertical
 from textual import events
 from textual.message import Message
 from textual.widgets import ContentSwitcher, Static, TextArea
 from rich.text import Text as RichText
 from rich.table import Table
 from rich.markup import escape
-_XML_SUPPRESS_TAG_OPEN = '<anreCommand'
-_XML_SUPPRESS_TAG_CLOSE = '</anreCommand>'
 
 class Agent:
 
@@ -84,7 +79,6 @@ class Agent:
         host, port = (parsed.hostname, parsed.port)
         if port is None:
             return
-        logger.debug('Checking backend %s:%s …', host, port)
         start = time.monotonic()
         loop = asyncio.get_running_loop()
         while time.monotonic() - start < timeout:
@@ -112,7 +106,6 @@ class Agent:
                 if event['type'] in ('text_delta', 'thinking_delta', 'error'):
                     await self._emit({'type': event['type'], 'payload': event['payload']})
             final = await es.result()
-            logger.debug(final)
             self.messages.append(final)
             await self._emit({'type': 'turn_end', 'payload': {'message': final}})
             if final['stop_reason'] in ('error', 'aborted'):
@@ -131,7 +124,6 @@ class Agent:
                 self._last_result_sig = result_sig
                 self._same_result_count = 0
             if self._same_result_count >= 2:
-                logger.warning('Doom-loop: same result %dx', self._same_result_count)
                 warn = f'\n\n[SYSTEM WARNING: Same tool result {self._same_result_count}x in a row. You are likely in a loop. Change your strategy.]\n\n'
                 for r in results:
                     if r.get('content') and isinstance(r['content'], list):
@@ -140,6 +132,7 @@ class Agent:
                         else:
                             r['content'].insert(0, {'type': 'text', 'text': warn})
             self.messages.extend(results)
+            await self._emit({'type': 'tool_results_ready', 'payload': {}})
             self.ctx['gwt'] = commit_worktree(self.ctx['gwt'], self.messages)
             if self._signal and self._signal.is_set():
                 final['stop_reason'] = 'aborted'
@@ -165,18 +158,6 @@ class Agent:
         await self._emit({'type': 'tool_end', 'payload': {'name': call['name'], 'is_error': result['is_error'], 'result': msg}})
         return msg
 
-def _truncate(text: str, n: int=50) -> str:
-    text = ' '.join(text.split())
-    return text if len(text) <= n else text[:max(0, n - 1)] + '…'
-
-def _message_text(message: dict) -> str:
-    content = message.get('content', '')
-    if isinstance(content, str):
-        return content
-    if isinstance(content, list):
-        return ''.join((str(b.get('text', '')) for b in content if isinstance(b, dict) and b.get('type') == 'text'))
-    return str(content)
-
 def _branch_index_title(parent_path: tuple[int, ...], existing_tabs: list) -> tuple[tuple[int, ...], str]:
     depth = len(parent_path) + 1
     child_count = sum((1 for t in existing_tabs if len(t.index_path) == depth and t.index_path[:-1] == parent_path))
@@ -184,131 +165,6 @@ def _branch_index_title(parent_path: tuple[int, ...], existing_tabs: list) -> tu
     title = 'branch-' + '-'.join((str(i) for i in index_path))
     return (index_path, title)
 
-def _tool_result_preview(result: dict | None) -> str:
-    if not result:
-        return ''
-    content = result.get('content') or []
-    if isinstance(content, list):
-        text = ''.join((str(b.get('text', '')) for b in content if isinstance(b, dict) and b.get('type') == 'text'))
-    else:
-        text = str(content)
-    return _truncate(text, 200)
-REPL_HELP = "Commands:\n  /help               show this message\n  /clear              clear conversation (transcript + agent memory)\n  /clear --soft       clear transcript only — keep agent memory in context\n  /history            show full conversation transcript\n  /history --raw      show raw API message log (debug)\n  /errors             show timestamped error log for this tab\n  /tools              list active tools\n  /branch [prompt]              open a branch tab (git switch -c); optional prompt runs immediately\n  /branch --as-worktree [prompt]  same but in a private worktree dir — safe for parallel runs\n  /abort              abort the running agent\n  /export [path]      export session to JSON\n  /exit  /quit        close branch tab, or exit the app\n\nKeys:\n  Enter               submit\n  Ctrl-J              insert newline in editor\n  Alt-1 … Alt-9       jump directly to tab N\n  Tab / Shift-Tab     cycle through tabs (git switch to that tab's branch)\n  Ctrl-C              abort running agent  (never exits the app)\n  Ctrl-D              close branch tab, or exit app (confirms if running)\n  Ctrl-R              recall last prompt into editor\n"
-
-class Tab:
-
-    def __init__(self, title: str, agent: Agent, is_main: bool=False, owns_worktree: bool=False, index_path: tuple[int, ...]=()):
-        self.agent = agent
-        self.title = title
-        self.is_main = is_main
-        self.owns_worktree = owns_worktree
-        self.index_path = index_path
-        self.panel: TabPanel | None = None
-        self.status: str = 'idle'
-        self.running_task: asyncio.Task | None = None
-        self.errors: list[tuple[str, str]] = []
-        self.last_error: str = ''
-        self.ephemeral_messages: list[dict] = []
-        self._stream_msg: dict | None = None
-        self._suppress_xml: bool = False
-        self._xml_tail: str = ''
-
-    @property
-    def is_running(self) -> bool:
-        return self.running_task is not None and (not self.running_task.done())
-
-    def apply_event(self, event: dict) -> None:
-        et = event.get('type')
-        payload = event.get('payload', {})
-        if et == 'agent_start':
-            self.status = 'running'
-            self._stream_msg = {'role': 'assistant', 'content': []}
-        elif et == 'text_delta' and self._stream_msg:
-            delta = self._filter_xml(payload.get('delta', ''))
-            if delta:
-                content = self._stream_msg['content']
-                if content and content[-1].get('type') == 'text' and (not content[-1].get('is_error')):
-                    content[-1]['text'] += delta
-                else:
-                    content.append({'type': 'text', 'text': delta})
-        elif et == 'thinking_delta' and self._stream_msg:
-            delta = payload.get('delta', '')
-            if delta:
-                content = self._stream_msg['content']
-                if content and content[-1].get('type') == 'thinking':
-                    content[-1]['text'] += delta
-                else:
-                    content.append({'type': 'thinking', 'text': delta})
-        elif et == 'tool_start' and self._stream_msg:
-            name = payload.get('name', 'tool')
-            args = payload.get('args') or {}
-            if isinstance(args, dict):
-                args = json.dumps(args, ensure_ascii=False)
-            self._stream_msg['content'].append({'type': 'toolCall', 'name': name, 'arguments': args, 'id': 'streaming'})
-        elif et == 'tool_end' and self._stream_msg:
-            if payload.get('is_error'):
-                self._stream_msg['content'].append({'type': 'text', 'text': payload.get('name', '') + ' failed', 'is_error': True})
-            else:
-                preview = _tool_result_preview(payload.get('result'))
-                if preview:
-                    self._stream_msg['content'].append({'type': 'text', 'text': preview})
-        elif et == 'error':
-            err = str(payload.get('error', payload))
-            if self._stream_msg:
-                self._stream_msg['content'].append({'type': 'text', 'text': err, 'is_error': True})
-            self.add_error(err)
-        elif et == 'agent_end':
-            if self._stream_msg and self._xml_tail and (not self._suppress_xml):
-                content = self._stream_msg['content']
-                if content and content[-1].get('type') == 'text':
-                    content[-1]['text'] += self._xml_tail
-                else:
-                    content.append({'type': 'text', 'text': self._xml_tail})
-            self._stream_msg = None
-            self._suppress_xml = False
-            self._xml_tail = ''
-            self.status = 'idle'
-
-    def _filter_xml(self, delta: str) -> str:
-        start_tag, end_tag = (_XML_SUPPRESS_TAG_OPEN, _XML_SUPPRESS_TAG_CLOSE)
-        data = self._xml_tail + delta
-        self._xml_tail = ''
-        out: list[str] = []
-        while data:
-            if self._suppress_xml:
-                end = data.find(end_tag)
-                if end == -1:
-                    return ''
-                data = data[end + len(end_tag):]
-                self._suppress_xml = False
-                continue
-            start = data.find(start_tag)
-            if start != -1:
-                out.append(data[:start])
-                data = data[start + len(start_tag):]
-                self._suppress_xml = True
-                continue
-            keep = 0
-            for i in range(1, len(start_tag)):
-                if data.endswith(start_tag[:i]):
-                    keep = i
-            if keep:
-                out.append(data[:-keep])
-                self._xml_tail = data[-keep:]
-            else:
-                out.append(data)
-            break
-        return ''.join(out)
-
-    def add_error(self, msg: str) -> None:
-        ts = datetime.datetime.now().strftime('%H:%M:%S')
-        self.errors.append((ts, msg))
-        self.last_error = msg
-
-    def clear_errors(self) -> None:
-        self.errors.clear()
-        self.last_error = ''
-
 def _clean_block_text(text: str) -> str:
     return text.lstrip('\n').rstrip()
 
@@ -336,60 +192,27 @@ def render_history(messages: list[dict]) -> Table:
                 prefix, style = ('≫', 'bold green')
             elif role == 'system':
                 prefix, style = ('·', 'dim')
-            elif role == '?':
-                prefix, style = ('·', 'dim')
+            elif role == 'command':
+                prefix, style = ('✓', 'blue')
+            elif b_type == 'thinking':
+                prefix, style = ('◌', 'dim italic')
+            elif role == 'toolResult':
+                prefix, style = ('→', 'dim yellow')
             elif b_type == 'toolCall':
                 prefix, style = ('⚙', 'yellow')
                 args = block.get('arguments', {})
                 if isinstance(args, dict):
                     args = json.dumps(args, ensure_ascii=False)
                 text = block.get('name', '') + ' ' + str(args)
-            elif b_type == 'thinking':
-                prefix, style = ('◌', 'dim italic')
-            elif role == 'toolResult':
-                prefix, style = ('→', 'dim yellow')
+            elif role == 'assistant':
+                prefix, style = ('○', '')
+                text = re.sub('\\s*<tool_call>.*?</tool_call>\\s*', '', text, flags=re.DOTALL).strip()
             text = _clean_block_text(text)
-            if not text and (not prefix):
+            if not text:
                 continue
             tbl.add_row(RichText(prefix, style=style), RichText(escape(text), style=style))
     return tbl
-
-class ChatLog(VerticalScroll):
-
-    def __init__(self, **kwargs):
-        super().__init__(**kwargs)
-        self._cached_msg_count: int = -1
-        self._stream_was_empty: bool = True
-
-    def compose(self) -> ComposeResult:
-        yield Static(id='cache')
-        yield Static(id='stream')
-
-    def refresh_stream(self, tab: Tab) -> None:
-        if tab._stream_msg:
-            self.query_one('#stream', Static).update(render_history([tab._stream_msg]))
-            if self._stream_was_empty:
-                self.scroll_end(animate=False)
-                self._stream_was_empty = False
-        else:
-            self.query_one('#stream', Static).update('')
-            self._stream_was_empty = True
-        if self.max_scroll_y - self.scroll_y < 3:
-            self.scroll_end(animate=False)
-
-    def refresh_cache(self, tab: Tab) -> None:
-        self._cached_msg_count = len(tab.agent.messages)
-        self.query_one('#cache', Static).update(render_history(tab.agent.messages + tab.ephemeral_messages))
-        self.scroll_end(animate=False)
-
-    def check_cache(self, tab: Tab) -> None:
-        if len(tab.agent.messages) != self._cached_msg_count:
-            self.refresh_cache(tab)
-
-    def clear_log(self) -> None:
-        self.query_one('#cache', Static).update('')
-        self.query_one('#stream', Static).update('')
-        self._cached_msg_count = 0
+REPL_HELP = 'Commands:\n  /help               show this message\n  /clear              clear conversation (transcript + agent memory)\n  /history            show full conversation transcript\n  /history --raw      show raw API message log (debug)\n  /errors             show timestamped error log for this tab\n  /tools              list active tools\n  /branch [prompt]              open a branch tab; optional prompt runs immediately\n  /branch --as-worktree [prompt]  same but in a private worktree dir\n  /abort              abort the running agent\n  /export [path]      export session to JSON\n  /exit  /quit        close branch tab, or exit the app\n\nKeys:\n  Enter               submit\n  Ctrl-J              insert newline in editor\n  Alt-1 … Alt-9       jump directly to tab N\n  Tab / Shift-Tab     cycle through tabs\n  Ctrl-C              abort running agent\n  Ctrl-D              close branch tab, or exit app\n  Ctrl-R              recall last prompt into editor\n'
 
 class InputBox(TextArea):
     BINDINGS = [Binding('ctrl+j', 'insert_newline', 'New line', show=False), Binding('enter', 'submit_text', 'Submit', show=False, priority=True), Binding('ctrl+r', 'recall_last', 'Recall', show=False), Binding('ctrl+d', 'request_close', 'Exit', show=False, priority=True)]
@@ -426,23 +249,123 @@ class InputBox(TextArea):
         lines = text.split('\n')
         self.move_cursor((len(lines) - 1, len(lines[-1])))
 
-class TabPanel(Static):
+class Tab(Vertical):
+    CSS = '\n    Tab > VerticalScroll {\n        height: 1fr;\n    }\n    #cache, #stream {\n        height: auto;\n        padding: 0 1;\n    }\n    #stream { min-height: 1; }\n    '
 
-    def __init__(self, tab: Tab, **kwargs):
-        super().__init__(id=f'panel-{id(tab):x}', **kwargs)
-        self.tab = tab
+    def __init__(self, title: str, agent: Agent, is_main: bool=False, owns_worktree: bool=False, index_path: tuple[int, ...]=()):
+        super().__init__(id=f'tab-{id(agent):x}')
+        self.title = title
+        self.agent = agent
+        self.is_main = is_main
+        self.owns_worktree = owns_worktree
+        self.index_path = index_path
+        self.status: str = 'idle'
+        self.running_task: asyncio.Task | None = None
+        self.errors: list[tuple[str, str]] = []
+        self.last_error: str = ''
+        self._stream_blocks: list[dict] = []
+        self._command_blocks: list[dict] = []
+        self._cache_count: int = -1
+
+    @property
+    def is_running(self) -> bool:
+        return self.running_task is not None and (not self.running_task.done())
 
     def compose(self) -> ComposeResult:
-        yield ChatLog()
-        yield InputBox()
+        with VerticalScroll(id='scroll'):
+            yield Static(id='cache')
+            yield Static(id='stream')
 
-    @property
-    def chat_log(self) -> ChatLog:
-        return self.query_one(ChatLog)
+    def apply_event(self, event: dict) -> None:
+        et = event.get('type')
+        payload = event.get('payload', {})
+        if et == 'agent_start':
+            self.status = 'running'
+            self._stream_blocks = []
+            self._command_blocks = []
+            self.refresh_cache()
+            self.refresh_stream()
+        elif et == 'turn_start':
+            self._stream_blocks = []
+            self._command_blocks = []
+            self.refresh_stream()
+        elif et == 'text_delta':
+            delta = payload.get('delta', '')
+            if delta:
+                if self._stream_blocks and self._stream_blocks[-1].get('type') == 'text' and (not self._stream_blocks[-1].get('is_error')):
+                    self._stream_blocks[-1]['text'] += delta
+                else:
+                    self._stream_blocks.append({'type': 'text', 'text': delta})
+            self.refresh_stream()
+        elif et == 'thinking_delta':
+            delta = payload.get('delta', '')
+            if delta:
+                if self._stream_blocks and self._stream_blocks[-1].get('type') == 'thinking':
+                    self._stream_blocks[-1]['text'] += delta
+                else:
+                    self._stream_blocks.append({'type': 'thinking', 'text': delta})
+            self.refresh_stream()
+        elif et == 'tool_start':
+            name = payload.get('name', 'tool')
+            self._stream_blocks.append({'type': 'toolCall', 'name': name, 'arguments': '…', 'id': 'streaming'})
+            self.refresh_stream()
+        elif et == 'tool_end':
+            if payload.get('is_error'):
+                self._stream_blocks.append({'type': 'text', 'text': f'{payload.get('name', 'tool')} failed', 'is_error': True})
+                self.refresh_stream()
+        elif et == 'tool_results_ready':
+            self.refresh_cache()
+            self._stream_blocks = []
+            self.refresh_stream()
+        elif et == 'error':
+            err = str(payload.get('error', payload))
+            self._stream_blocks.append({'type': 'text', 'text': err, 'is_error': True})
+            ts = datetime.datetime.now().strftime('%H:%M:%S')
+            self.errors.append((ts, err))
+            self.last_error = err
+            self.refresh_stream()
+        elif et == 'turn_end':
+            self._stream_blocks = []
+            self.refresh_stream()
+            self.refresh_cache()
+        elif et == 'agent_end':
+            self._stream_blocks = []
+            self.refresh_stream()
+            self.refresh_cache()
+            self.status = 'idle'
 
-    @property
-    def input_box(self) -> InputBox:
-        return self.query_one(InputBox)
+    def refresh_cache(self) -> None:
+        if len(self.agent.messages) != self._cache_count:
+            self._cache_count = len(self.agent.messages)
+            self.query_one('#cache', Static).update(render_history(self.agent.messages))
+            scroll = self.query_one('#scroll', VerticalScroll)
+            self.app.call_after_refresh(scroll.scroll_end, animate=False)
+
+    def refresh_stream(self) -> None:
+        msgs = []
+        if self._stream_blocks:
+            msgs.append({'role': 'assistant', 'content': self._stream_blocks})
+        if self._command_blocks and False:
+            msgs.extend(self._command_blocks)
+        if not msgs:
+            msgs.extend(self._command_blocks)
+        if msgs:
+            self.query_one('#stream', Static).update(render_history(msgs))
+            scroll = self.query_one('#scroll', VerticalScroll)
+            self.app.call_after_refresh(scroll.scroll_end, animate=False)
+        else:
+            self.query_one('#stream', Static).update('')
+
+    def show_command(self, cmd, text: str) -> None:
+        self._command_blocks.extend([{'role': 'user', 'content': cmd}, {'role': 'command', 'content': text}])
+        self.refresh_stream()
+
+    def clear_log(self) -> None:
+        self.query_one('#cache', Static).update('')
+        self.query_one('#stream', Static).update('')
+        self._cache_count = 0
+        self._command_blocks = []
+        self._stream_blocks = []
 
 class TabBar(Static):
 
@@ -481,9 +404,6 @@ class TabBar(Static):
 
 class StatusBar(Static):
 
-    def __init__(self, **kwargs):
-        super().__init__('', **kwargs)
-
     def render_status(self, tab: Tab, model: str | None) -> None:
         t = RichText(no_wrap=True, overflow='ellipsis')
         t.append(f' {tab.title}', style='bold')
@@ -507,15 +427,15 @@ class HelpBar(Static):
         self._idle_text = RichText('/help  Ctrl-J newline  Alt-1…9 tabs  Ctrl-C abort  Ctrl-D exit  Ctrl-R recall', style='dim')
         super().__init__(self._idle_text, **kwargs)
 
+    def show_idle(self) -> None:
+        self.update(self._idle_text)
+
     def show_error(self, msg: str) -> None:
         t = RichText()
         t.append('✗ ', style='bold red')
         t.append(escape(msg), style='red')
         self.update(t)
 
-    def show_idle(self) -> None:
-        self.update(self._idle_text)
-
     def show_confirm(self, msg: str) -> None:
         t = RichText()
         t.append('⚠ ', style='bold yellow')
@@ -523,8 +443,8 @@ class HelpBar(Static):
         self.update(t)
 
 class ReplApp(App[None]):
-    CSS = '\n    ReplApp {\n        layout: vertical;\n        background: $background;\n    }\n    ContentSwitcher {\n        height: 1fr;\n    }\n    ChatLog {\n        height: 1fr;\n        padding: 0 1;\n    }\n\n    ChatLog > Static {\n        text-align: left;\n        align-horizontal: left;\n    }\n\n    #stream {\n        min-height: 1;\n    }\n    InputBox {\n        height: auto;\n        min-height: 3;\n        max-height: 8;\n        border: none;\n        border-top: tall $panel-darken-1;\n        background: $panel;\n        padding: 0 2;\n        color: $text;\n    }\n    InputBox:focus {\n        border-top: tall $accent;\n    }\n    TabBar {\n        height: 1;\n        background: $panel;\n        padding: 0 1;\n    }\n    StatusBar {\n        height: 1;\n        background: $panel;\n        color: $text-muted;\n        padding: 0 1;\n    }\n    HelpBar {\n        height: 1;\n        color: $text-muted;\n        padding: 0 1;\n    }\n    '
-    BINDINGS = [Binding('ctrl+c', 'abort_agent', 'Abort', priority=True, show=False), Binding('ctrl+d', 'close_or_exit', 'Exit', show=False), Binding('tab', 'next_tab', 'Next tab', show=False), Binding('shift+tab', 'prev_tab', 'Prev tab', show=False), Binding('alt+1', 'switch_tab(1)', 'Tab 1', show=False), Binding('alt+2', 'switch_tab(2)', 'Tab 2', show=False), Binding('alt+3', 'switch_tab(3)', 'Tab 3', show=False), Binding('alt+4', 'switch_tab(4)', 'Tab 4', show=False), Binding('alt+5', 'switch_tab(5)', 'Tab 5', show=False), Binding('alt+6', 'switch_tab(6)', 'Tab 6', show=False), Binding('alt+7', 'switch_tab(7)', 'Tab 7', show=False), Binding('alt+8', 'switch_tab(8)', 'Tab 8', show=False), Binding('alt+9', 'switch_tab(9)', 'Tab 9', show=False)]
+    CSS = '\n    ReplApp { layout: vertical; background: $background; }\n    ContentSwitcher { height: 1fr; }\n    InputBox {\n        height: auto;\n        min-height: 3;\n        max-height: 8;\n        border: none;\n        border-top: tall $panel-darken-1;\n        background: $panel;\n        padding: 0 2;\n        color: $text;\n    }\n    InputBox:focus { border-top: tall $accent; }\n    TabBar { height: 1; background: $panel; padding: 0 1; }\n    StatusBar { height: 1; background: $panel; color: $text-muted; padding: 0 1; }\n    HelpBar { height: 1; color: $text-muted; padding: 0 1; }\n    '
+    BINDINGS = [Binding('ctrl+c', 'abort_agent', 'Abort', priority=True, show=False), Binding('ctrl+d', 'close_or_exit', 'Exit', show=False), Binding('tab', 'next_tab', 'Next tab', show=False), Binding('shift+tab', 'prev_tab', 'Prev tab', show=False), Binding('ctrl+1', 'switch_tab(1)', 'Tab 1', show=False), Binding('ctrl+2', 'switch_tab(2)', 'Tab 2', show=False), Binding('ctrl+3', 'switch_tab(3)', 'Tab 3', show=False), Binding('ctrl+4', 'switch_tab(4)', 'Tab 4', show=False), Binding('ctrl+5', 'switch_tab(5)', 'Tab 5', show=False), Binding('ctrl+6', 'switch_tab(6)', 'Tab 6', show=False), Binding('ctrl+7', 'switch_tab(7)', 'Tab 7', show=False), Binding('ctrl+8', 'switch_tab(8)', 'Tab 8', show=False), Binding('ctrl+9', 'switch_tab(9)', 'Tab 9', show=False)]
 
     def __init__(self, agent: Agent, init_prompt: str | None=None) -> None:
         super().__init__()
@@ -533,19 +453,17 @@ class ReplApp(App[None]):
         self._unsubscribers: dict[int, Callable] = {}
         self._pending_init = init_prompt.strip() if init_prompt else None
         self._confirm_close = False
-        self._dirty: set[int] = set()
         self._attach_agent(self.tabs[0])
 
     def compose(self) -> ComposeResult:
         yield TabBar(id='tabbar')
-        switcher = ContentSwitcher(TabPanel(self.tabs[0]), initial=f'panel-{id(self.tabs[0]):x}')
-        yield switcher
+        yield ContentSwitcher(self.tabs[0], initial=self.tabs[0].id)
+        yield InputBox()
         yield StatusBar(id='statusbar')
         yield HelpBar(id='helpbar')
 
     def on_mount(self) -> None:
         self._refresh_chrome()
-        self.set_interval(1 / 20, self._flush_dirty)
         self._switch_to(0)
         if self._pending_init:
             self.set_timer(0.05, self._run_pending_init)
@@ -555,44 +473,17 @@ class ReplApp(App[None]):
             prompt, self._pending_init = (self._pending_init, None)
             asyncio.create_task(self._run_submit(prompt))
 
-    def _flush_dirty(self) -> None:
-        if not self._dirty:
-            return
-        tab_by_id = {id(t): (i, t) for i, t in enumerate(self.tabs)}
-        for tab_id in list(self._dirty):
-            entry = tab_by_id.get(tab_id)
-            if entry is None:
-                continue
-            idx, tab = entry
-            panel = self._panel_for_index(idx)
-            if panel:
-                panel.chat_log.check_cache(tab)
-                panel.chat_log.refresh_stream(tab)
-        self._dirty.clear()
-        self._refresh_chrome()
-
     def _refresh_chrome(self) -> None:
         try:
             self.query_one('#tabbar', TabBar).render_tabs(self.tabs, self.active_index)
             self.query_one('#statusbar', StatusBar).render_status(self.active_tab, self.active_tab.agent.model)
         except Exception:
-            logger.debug('_refresh_chrome: widget not available', exc_info=True)
+            pass
 
     @property
     def active_tab(self) -> Tab:
         return self.tabs[self.active_index]
 
-    def _panel_for_tab(self, tab: Tab) -> TabPanel | None:
-        try:
-            return self.query_one(f'#panel-{id(tab):x}', TabPanel)
-        except Exception:
-            return None
-
-    def _panel_for_index(self, idx: int) -> TabPanel | None:
-        if 0 <= idx < len(self.tabs):
-            return self._panel_for_tab(self.tabs[idx])
-        return None
-
     def _attach_agent(self, tab: Tab) -> None:
         key = id(tab.agent)
         if key in self._unsubscribers:
@@ -600,8 +491,8 @@ class ReplApp(App[None]):
 
         async def on_event(event: dict) -> None:
             tab.apply_event(event)
-            if tab in self.tabs:
-                self._dirty.add(id(tab))
+            if event['type'] in ('agent_start', 'agent_end', 'turn_end'):
+                self._refresh_chrome()
         self._unsubscribers[key] = tab.agent.subscribe(on_event)
 
     def on_input_box_submit(self, message: InputBox.Submit) -> None:
@@ -609,12 +500,9 @@ class ReplApp(App[None]):
 
     def on_input_box_recall_last(self, _msg: InputBox.RecallLast) -> None:
         tab = self.active_tab
-        panel = self._panel_for_tab(tab)
-        if not panel:
-            return
         real = [m for m in tab.agent.messages if m.get('role') == 'user']
         if real:
-            panel.input_box.set_text_and_end(real[-1].get('content', ''))
+            self.query_one(InputBox).set_text_and_end(real[-1].get('content', ''))
 
     def on_input_box_close_request(self, _msg: InputBox.CloseRequest) -> None:
         self._do_close_or_exit()
@@ -625,9 +513,9 @@ class ReplApp(App[None]):
             return
         self._confirm_close = False
         tab = self.active_tab
-        tab.clear_errors()
-        tab.ephemeral_messages.clear()
-        self._show_help_idle()
+        tab.errors.clear()
+        tab.last_error = ''
+        self.query_one('#helpbar', HelpBar).show_idle()
         if text.startswith('/'):
             await self._handle_command(tab, text)
             return
@@ -635,125 +523,158 @@ class ReplApp(App[None]):
             self._do_close_or_exit()
             return
         if tab.is_running:
-            self._show_error(tab, 'Agent is running — /abort first, or switch tabs (Alt-N).')
+            self.query_one('#helpbar', HelpBar).show_error('Agent is running — /abort first.')
             return
         tab.running_task = asyncio.create_task(self._run_agent(tab, text))
-        self._dirty.add(id(tab))
 
     async def _run_agent(self, tab: Tab, text: str) -> None:
         try:
             await tab.agent.run(text)
         except Exception as exc:
-            tab.add_error(str(exc))
+            tab.errors.append((datetime.datetime.now().strftime('%H:%M:%S'), str(exc)))
+            tab.last_error = str(exc)
             tab.status = 'error'
-            try:
-                self.query_one('#helpbar', HelpBar).show_error(str(exc))
-            except Exception:
-                logger.debug('_run_agent: helpbar not available', exc_info=True)
+            self.query_one('#helpbar', HelpBar).show_error(str(exc))
         finally:
+            tab.running_task = None
             if not tab.last_error:
                 tab.status = 'idle'
-            if tab in self.tabs:
-                self._dirty.add(id(tab))
+            self._refresh_chrome()
 
     async def _handle_command(self, tab: Tab, text: str) -> None:
         cmd, _, arg = text.partition(' ')
         cmd = cmd.lower().strip()
         arg = arg.strip()
-        panel = self._panel_for_tab(tab)
         if cmd == '/help':
-            tab.ephemeral_messages.append({'role': '?', 'content': REPL_HELP})
+            tab.show_command(text, REPL_HELP)
         elif cmd == '/clear':
-            tab.ephemeral_messages.clear()
             tab.agent.messages.clear()
-            tab.status = 'cleared'
-            if panel:
-                panel.chat_log.clear_log()
+            tab.clear_log()
             self._refresh_chrome()
         elif cmd == '/history':
             if arg == '--raw':
-                tab.ephemeral_messages.append({'role': '?', 'content': json.dumps(tab.agent.messages, indent=2)})
+                raw_json = json.dumps(tab.agent.messages, indent=2, default=str)
+                tab.show_command(text, raw_json)
             else:
-                real = [m for m in tab.agent.messages if m.get('role') in {'user', 'assistant'}]
-                if not real:
-                    tab.ephemeral_messages.append({'role': '?', 'content': 'No conversation yet.'})
+                user_msgs = [m for m in tab.agent.messages if m.get('role') == 'user']
+                if not user_msgs:
+                    tab.show_command(text, 'No prompts yet.')
                 else:
-                    parts = []
-                    for i, m in enumerate(real):
-                        if m['role'] == 'user':
-                            parts.append(f'Turn {i + 1}  {_message_text(m)}')
-                        elif m['role'] == 'assistant':
-                            parts.append(f'  {_message_text(m)}')
-                    tab.ephemeral_messages.append({'role': '?', 'content': 'Conversation transcript\n' + '\n'.join(parts)})
+                    lines = []
+                    gwt = tab.agent.ctx.get('gwt')
+                    commit_stats = []
+                    if gwt and getattr(gwt, 'worktree', None):
+                        try:
+                            commit_stats = get_commit_history_with_stats(gwt.worktree, limit=len(user_msgs) + 5)
+                        except Exception as e:
+                            logger.warning(f'Failed to get commit stats: {e}')
+                    turn_commits = {}
+                    for c in commit_stats:
+                        turn = c.get('user_turns', 0)
+                        if turn > 0:
+                            if turn not in turn_commits:
+                                turn_commits[turn] = []
+                            turn_commits[turn].append(c)
+                    for i, m in enumerate(user_msgs, 1):
+                        content = m.get('content', '')
+                        if isinstance(content, list):
+                            content = ' '.join((b.get('text', '') for b in content if isinstance(b, dict) and b.get('type') == 'text'))
+                        content = re.sub('\\s+', '  ', content).strip()
+                        if len(content) > 100:
+                            content = content[:100] + '…'
+                        line = f'{i}. {content}'
+                        if i in turn_commits:
+                            for c in turn_commits[i]:
+                                ref_str = c.get('refs', '').strip(' ()')
+                                if ref_str.startswith('HEAD -> '):
+                                    ref_str = ref_str[8:]
+                                ref_str = ref_str.replace('HEAD, ', '').strip()
+                                hash_str = f'[{c['short_sha']}]'
+                                if ref_str:
+                                    hash_str += f' on {ref_str}'
+                                else:
+                                    hash_str += ' (detached)'
+                                line += f'\n   ↪ Commit {hash_str}'
+                                seen = set()
+                                unique_files = [f for f in c['files'] if not (f in seen or seen.add(f))]
+                                if unique_files:
+                                    file_lines = '\n     '.join(unique_files[:8])
+                                    if len(unique_files) > 8:
+                                        file_lines += f'\n     ... and {len(unique_files) - 8} more'
+                                    line += f'\n     {file_lines}'
+                        lines.append(line)
+                    tab.show_command(text, '\n'.join(lines))
         elif cmd == '/errors':
             if not tab.errors:
-                tab.ephemeral_messages.append({'role': '?', 'content': 'No errors recorded in this tab.'})
+                tab.show_command('No errors recorded.')
             else:
                 lines = [f'{ts}  {msg}' for ts, msg in tab.errors[-30:]]
-                tab.ephemeral_messages.append({'role': '?', 'content': 'Error log\n' + '\n'.join(lines)})
+                tab.show_command(text, 'Error log\n' + '\n'.join(lines))
         elif cmd == '/tools':
             tools = tab.agent.tools
             if not tools:
-                tab.ephemeral_messages.append({'role': '?', 'content': 'No tools enabled.'})
+                tab.show_command(text, 'No tools enabled.')
             else:
                 body = '\n'.join((f'{t.name}  {t.description}' for t in tools))
-                tab.ephemeral_messages.append({'role': '?', 'content': f'Active tools ({len(tools)})\n{body}'})
+                tab.show_command(text, f'Active tools ({len(tools)})\n{body}')
         elif cmd == '/abort':
             if tab.is_running:
                 tab.agent.abort()
                 tab.status = 'aborting…'
                 self._refresh_chrome()
             else:
-                self._show_error(tab, 'Nothing is running.')
+                self.query_one('#helpbar', HelpBar).show_error('Nothing is running.')
         elif cmd == '/branch':
-            await self._open_branch(arg)
+            as_worktree = False
+            prompt = arg
+            if '--as-worktree' in arg:
+                as_worktree = True
+                prompt = arg.replace('--as-worktree', '').strip()
+            parent = self.active_tab
+            child = parent.agent.branch()
+            index_path, title = _branch_index_title(parent.index_path, self.tabs)
+            owns_worktree = False
+            gwt = child.ctx.get('gwt')
+            if as_worktree:
+                repo_dir = gwt.worktree if gwt else child.ctx.get('cwd', os.getcwd())
+                new_gwt = create_worktree(repo_dir, prefix=title)
+                if new_gwt is None:
+                    self.query_one('#helpbar', HelpBar).show_error(f'git worktree creation failed for {title!r}')
+                    return
+                child.ctx['gwt'] = new_gwt
+                child.ctx['cwd'] = new_gwt.worktree
+                if 'env' in child.ctx:
+                    child.ctx['env']['PWD'] = new_gwt.worktree
+                owns_worktree = True
+            elif gwt:
+                try:
+                    new_gwt = git_new_branch(gwt.worktree, title)
+                    child.ctx['gwt'] = new_gwt
+                except GitError as exc:
+                    logger.warning('git_new_branch failed for tab %r: %s', title, exc)
+            new_tab = Tab(title, child, owns_worktree=owns_worktree, index_path=index_path)
+            self.tabs.append(new_tab)
+            self._attach_agent(new_tab)
+            switcher = self.query_one(ContentSwitcher)
+            await switcher.mount(new_tab)
+            self._switch_to(len(self.tabs) - 1)
+            if prompt:
+                await self._run_submit(prompt)
         elif cmd == '/export':
-            self._export_tab(tab, arg)
+            ts = datetime.datetime.now().strftime('%Y%m%d_%H%M%S')
+            path = arg or os.path.join(os.getcwd(), f'session_{ts}.json')
+            data = {'version': 1, 'exported_at': ts, 'system': tab.agent.system, 'messages': tab.agent.messages}
+            try:
+                with open(path, 'w', encoding='utf-8') as f:
+                    json.dump(data, f, indent=2, ensure_ascii=False)
+                tab.status = f'exported → {path}'
+                self._refresh_chrome()
+            except OSError as exc:
+                self.query_one('#helpbar', HelpBar).show_error(f'Export failed: {exc}')
         elif cmd in {'/exit', '/quit'}:
             self._do_close_or_exit()
         else:
-            self._show_error(tab, f'Unknown command: {cmd!r}  — try /help')
-        if panel:
-            panel.chat_log.refresh_cache(tab)
-
-    async def _open_branch(self, arg: str='') -> None:
-        as_worktree = False
-        prompt = arg
-        if '--as-worktree' in arg:
-            as_worktree = True
-            prompt = arg.replace('--as-worktree', '').strip()
-        parent = self.active_tab
-        child = parent.agent.branch()
-        index_path, title = _branch_index_title(parent.index_path, self.tabs)
-        owns_worktree = False
-        gwt = child.ctx.get('gwt')
-        if as_worktree:
-            repo_dir = gwt.worktree if gwt else child.ctx.get('cwd', os.getcwd())
-            new_gwt = create_worktree(repo_dir, prefix=title)
-            if new_gwt is None:
-                self._show_error(parent, f'git worktree creation failed for {title!r}')
-                return
-            child.ctx['gwt'] = new_gwt
-            child.ctx['cwd'] = new_gwt.worktree
-            if 'env' in child.ctx:
-                child.ctx['env']['PWD'] = new_gwt.worktree
-            owns_worktree = True
-        elif gwt:
-            try:
-                new_gwt = git_new_branch(gwt.worktree, title)
-                child.ctx['gwt'] = new_gwt
-            except GitError as exc:
-                logger.warning('git_new_branch failed for tab %r: %s', title, exc)
-        new_tab = Tab(title, child, owns_worktree=owns_worktree, index_path=index_path)
-        self.tabs.append(new_tab)
-        self._attach_agent(new_tab)
-        panel = TabPanel(new_tab)
-        new_tab.panel = panel
-        switcher = self.query_one(ContentSwitcher)
-        await switcher.mount(panel)
-        self._switch_to(len(self.tabs) - 1)
-        if prompt:
-            await self._run_submit(prompt)
+            self.query_one('#helpbar', HelpBar).show_error(f'Unknown command: {cmd!r}  — try /help')
 
     def _switch_to(self, idx: int) -> None:
         if not 0 <= idx < len(self.tabs):
@@ -769,33 +690,18 @@ class ReplApp(App[None]):
                     next_tab.agent.ctx['gwt'] = updated
                 except GitError as exc:
                     logger.warning('git switch to %r failed: %s', next_gwt.branch, exc)
-                    try:
-                        self.query_one('#helpbar', HelpBar).show_error(f'git switch failed: {exc}')
-                    except Exception:
-                        pass
+                    self.query_one('#helpbar', HelpBar).show_error(f'git switch failed: {exc}')
         self.active_index = idx
         self._confirm_close = False
         try:
-            self.query_one(ContentSwitcher).current = f'panel-{id(self.tabs[idx]):x}'
+            self.query_one(ContentSwitcher).current = self.tabs[idx].id
         except Exception:
-            logger.debug('_switch_to: ContentSwitcher not available', exc_info=True)
-        panel = self._panel_for_index(idx)
-        if panel:
-            panel.chat_log.check_cache(self.tabs[idx])
-            panel.input_box.focus()
+            pass
+        tab = self.tabs[idx]
+        tab.refresh_cache()
+        self.query_one(InputBox).focus()
         self._refresh_chrome()
-        self._sync_help_bar()
-
-    def _sync_help_bar(self) -> None:
-        tab = self.active_tab
-        try:
-            hb = self.query_one('#helpbar', HelpBar)
-            if tab.last_error:
-                hb.show_error(tab.last_error)
-            else:
-                hb.show_idle()
-        except Exception:
-            logger.debug('_sync_help_bar: helpbar not available', exc_info=True)
+        self.query_one('#helpbar', HelpBar).show_idle()
 
     def on_tab_bar_switch_to(self, msg: TabBar.SwitchTo) -> None:
         self._switch_to(msg.index)
@@ -817,10 +723,7 @@ class ReplApp(App[None]):
         if tab.is_running:
             if not self._confirm_close:
                 self._confirm_close = True
-                try:
-                    self.query_one('#helpbar', HelpBar).show_confirm('Agent is running — press Ctrl-D again to force close.')
-                except Exception:
-                    logger.debug('_do_close_or_exit: helpbar not available', exc_info=True)
+                self.query_one('#helpbar', HelpBar).show_confirm('Agent is running — press Ctrl-D again to force close.')
                 return
             tab.agent.abort()
             if tab.running_task:
@@ -830,10 +733,7 @@ class ReplApp(App[None]):
             self.exit()
             return
         if tab.is_main:
-            try:
-                self.query_one('#helpbar', HelpBar).show_error('Close all branch tabs first, then Ctrl-D to exit.')
-            except Exception:
-                logger.debug('_do_close_or_exit: helpbar not available', exc_info=True)
+            self.query_one('#helpbar', HelpBar).show_error('Close all branch tabs first, then Ctrl-D to exit.')
             return
         if (unsub := self._unsubscribers.pop(id(tab.agent), None)):
             unsub()
@@ -844,9 +744,7 @@ class ReplApp(App[None]):
                     cleanup_worktree(gwt)
                 except Exception as exc:
                     logger.warning('cleanup_worktree failed for %r: %s', tab.title, exc)
-        panel = self._panel_for_tab(tab)
-        if panel:
-            panel.remove()
+        tab.remove()
         self.tabs.pop(self.active_index)
         self.active_index = max(0, min(self.active_index, len(self.tabs) - 1))
         self._switch_to(self.active_index)
@@ -858,31 +756,6 @@ class ReplApp(App[None]):
             tab.status = 'aborting…'
             self._refresh_chrome()
 
-    def _export_tab(self, tab: Tab, out_path: str) -> None:
-        ts = datetime.datetime.now().strftime('%Y%m%d_%H%M%S')
-        path = out_path or os.path.join(os.getcwd(), f'session_{ts}.json')
-        data = {'version': 1, 'exported_at': ts, 'system': tab.agent.system, 'messages': tab.agent.messages}
-        try:
-            with open(path, 'w', encoding='utf-8') as f:
-                json.dump(data, f, indent=2, ensure_ascii=False)
-            tab.status = f'exported → {path}'
-            self._refresh_chrome()
-        except OSError as exc:
-            self._show_error(tab, f'Export failed: {exc}')
-
-    def _show_error(self, tab: Tab, msg: str) -> None:
-        tab.add_error(msg)
-        try:
-            self.query_one('#helpbar', HelpBar).show_error(msg)
-        except Exception:
-            logger.debug('_show_error: helpbar not available', exc_info=True)
-
-    def _show_help_idle(self) -> None:
-        try:
-            self.query_one('#helpbar', HelpBar).show_idle()
-        except Exception:
-            logger.debug('_show_help_idle: helpbar not available', exc_info=True)
-
 async def _stream_to_stdout(agent: Agent, user_input: str) -> None:
     result = await agent.run(user_input)
     text = ''.join((block.get('text', '') for block in result.get('content', []) if block.get('type') == 'text'))

{mlx_code-0.0.12 → mlx_code-0.0.14}/mlx_code/view_git.py

@@ -311,7 +311,22 @@ def draw_tree(win, state: State, h: int, w: int):
             toggle = '  '
         indent = '  ' * node.depth
         if node.kind == 'base':
-            content = f'● {node.committed_dt}  {node.summary}'
+            branch_prefixes = []
+            for child in node.children:
+                if child.branch_name:
+                    if '--' in child.branch_name:
+                        prefix = child.branch_name.split('--', 1)[0]
+                    elif '/' in child.branch_name:
+                        prefix = child.branch_name.split('/', 1)[0]
+                    else:
+                        prefix = child.branch_name
+                    if prefix not in branch_prefixes:
+                        branch_prefixes.append(prefix)
+            branch_str = ' '.join(branch_prefixes)
+            if branch_str:
+                content = f'● {node.committed_dt}  {branch_str}  {node.summary}'
+            else:
+                content = f'● {node.committed_dt}  {node.summary}'
         elif node.kind == 'branch_label':
             inner = node.branch_name.split('/', 1)[1] if node.branch_name and '/' in node.branch_name else node.branch_name or ''
             seg = inner.split('-', 1)

{mlx_code-0.0.12 → mlx_code-0.0.14}/mlx_code.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: mlx-code
-Version: 0.0.12
+Version: 0.0.14
 Summary: Coding Agent for Mac
 Home-page: https://josefalbers.github.io/mlx-code/
 Author: J Joe

{mlx_code-0.0.12 → mlx_code-0.0.14}/setup.py

@@ -11,7 +11,7 @@ setup(
     author_email="albersj66@gmail.com",
     author="J Joe",
     license="Apache-2.0",
-    version="0.0.12",
+    version="0.0.14",
     readme="README.md",
     description="Coding Agent for Mac",
     long_description=open("README.md").read(),

{mlx_code-0.0.12 → mlx_code-0.0.14}/tests/test.py

@@ -171,7 +171,7 @@ class TestReplHelpers(unittest.TestCase):
         tab.apply_event({'type': 'error', 'payload': {'error': 'something broke'}})
         self.assertEqual(tab.last_error, 'something broke')
         error_blocks = [b for b in tab._stream_msg['content'] if b.get('is_error')]
-        self.assertTrue(any('something broke' in b.get('text', '') for b in error_blocks))
+        self.assertTrue(any(('something broke' in b.get('text', '') for b in error_blocks)))
 
     def test_tab_apply_event_tool_start_and_end(self):
         tab = Tab('main', Agent(api=EchoChat(), tool_names=[]))
@@ -181,15 +181,15 @@ class TestReplHelpers(unittest.TestCase):
         self.assertEqual(len(tool_calls), 1)
         self.assertEqual(tool_calls[0]['name'], 'Read')
         tab.apply_event({'type': 'tool_end', 'payload': {'name': 'Read', 'is_error': False, 'result': {'content': [{'type': 'text', 'text': 'file contents'}]}}})
-        text_blocks = [b for b in tab._stream_msg['content'] if b.get('type') == 'text' and not b.get('is_error')]
-        self.assertTrue(any('file contents' in b.get('text', '') for b in text_blocks))
+        text_blocks = [b for b in tab._stream_msg['content'] if b.get('type') == 'text' and (not b.get('is_error'))]
+        self.assertTrue(any(('file contents' in b.get('text', '') for b in text_blocks)))
 
     def test_tab_apply_event_tool_end_error_appends_failure_text(self):
         tab = Tab('main', Agent(api=EchoChat(), tool_names=[]))
         tab.apply_event({'type': 'agent_start', 'payload': {}})
         tab.apply_event({'type': 'tool_end', 'payload': {'name': 'Write', 'is_error': True, 'result': None}})
         error_blocks = [b for b in tab._stream_msg['content'] if b.get('is_error')]
-        self.assertTrue(any('Write failed' in b.get('text', '') for b in error_blocks))
+        self.assertTrue(any(('Write failed' in b.get('text', '') for b in error_blocks)))
 
     def test_echo_chat_outputs_final_text_only_to_stdout(self):
 
@@ -214,6 +214,5 @@ class TestReplHelpers(unittest.TestCase):
                 await repl(agent)
             return fake_stdout.getvalue()
         self.assertIn('echo: piped input', asyncio.run(run()))
-
 if __name__ == '__main__':
-    unittest.main()
+    unittest.main()