opencode-db 0.4.7__tar.gz → 0.4.9__tar.gz

{opencode_db-0.4.7/opencode_db.egg-info → opencode_db-0.4.9}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: opencode-db
-Version: 0.4.7
+Version: 0.4.9
 Summary: OpenCode database CLI manager — browse, export, analyze, clean up sessions
 Project-URL: Homepage, https://github.com/VasilevNStas/opencode-db
 Project-URL: Source, https://github.com/VasilevNStas/opencode-db

{opencode_db-0.4.7 → opencode_db-0.4.9}/cmd_costs.py

@@ -3,9 +3,7 @@
 Стоимость берётся напрямую из поля session.cost БД OpenCode.
 """
 
-from typing import Literal
-
-from db import get_session_info, get_session_title, parse_model
+from db import SessionError, get_session_info, get_session_title, parse_model
 from i18n import _
 from utils import format_cost, format_tokens
 
@@ -19,7 +17,7 @@ def register(subparsers) -> None:
     p.add_argument("--limit", type=int, default=30, help="Max rows")
 
 
-def run(args, db) -> Literal[0]:
+def run(args, db) -> int:
     if args.session_id:
         return _show_session(db, args.session_id, args.json)
 
@@ -29,8 +27,12 @@ def run(args, db) -> Literal[0]:
     return _show_list(db, args.project, args.limit, args.json)
 
 
-def _show_session(db, session_id, as_json) -> Literal[0]:
-    info = get_session_info(db, session_id)
+def _show_session(db, session_id, as_json) -> int:
+    try:
+        info = get_session_info(db, session_id)
+    except SessionError as e:
+        print(e.message)
+        return 1
     title = get_session_title(info)
     model = parse_model(info)
 
@@ -73,7 +75,7 @@ def _show_session(db, session_id, as_json) -> Literal[0]:
     return 0
 
 
-def _show_total(db, project_id, as_json) -> Literal[0]:
+def _show_total(db, project_id, as_json) -> int:
     where = "1=1"
     params = []
 
@@ -126,7 +128,7 @@ def _show_total(db, project_id, as_json) -> Literal[0]:
     return 0
 
 
-def _show_list(db, project_id, limit, as_json) -> Literal[0]:
+def _show_list(db, project_id, limit, as_json) -> int:
     where = "1=1"
     params = []
 

{opencode_db-0.4.7 → opencode_db-0.4.9}/cmd_delete.py

@@ -1,8 +1,7 @@
 """Команда delete: удаление сессии."""
 
-from typing import Literal
-
 from db import (
+    SessionError,
     get_message_count,
     get_part_count,
     get_session_info,
@@ -20,8 +19,12 @@ def register(subparsers) -> None:
     p.add_argument("--force", "-f", action="store_true", help="Skip confirmation")
 
 
-def run(args, db) -> Literal[0]:
-    info = get_session_info(db, args.session_id)
+def run(args, db) -> int:
+    try:
+        info = get_session_info(db, args.session_id)
+    except SessionError as e:
+        print(e.message)
+        return 1
     session_id = info["id"]
     title = get_session_title(info)
     model = parse_model(info)

{opencode_db-0.4.7 → opencode_db-0.4.9}/cmd_export.py

@@ -7,9 +7,9 @@
 """
 
 import os
-from typing import Literal
 
 from db import (
+    SessionError,
     get_latest_session,
     get_messages,
     get_recent_sessions,
@@ -47,20 +47,28 @@ def register(subparsers) -> None:
     )
 
 
-def _export_by_id(db, session_id, output_dir, force, note, full) -> Literal[1] | Literal[0]:
-    session_info = get_session_info(db, session_id)
+def _export_by_id(db, session_id, output_dir, force, note, full) -> int:
+    try:
+        session_info = get_session_info(db, session_id)
+    except SessionError as e:
+        print(e.message)
+        return 1
     return _do_export(db, session_info, output_dir, force, note, full)
 
 
-def _export_latest(db, output_dir, force, note, full) -> Literal[1] | Literal[0]:
-    session_id = get_latest_session(db)
-    session_info = get_session_info(db, session_id)
+def _export_latest(db, output_dir, force, note, full) -> int:
+    try:
+        session_id = get_latest_session(db)
+        session_info = get_session_info(db, session_id)
+    except SessionError as e:
+        print(e.message)
+        return 1
     title = get_session_title(session_info)
     print(_("session.latest", title=title))
     return _do_export(db, session_info, output_dir, force, note, full)
 
 
-def _export_interactive(db, output_dir, force, note, full) -> Literal[1] | Literal[0]:
+def _export_interactive(db, output_dir, force, note, full) -> int:
     sessions = get_recent_sessions(db)
 
     if not sessions:
@@ -102,11 +110,15 @@ def _export_interactive(db, output_dir, force, note, full) -> Literal[1] | Liter
     session_id = sessions[idx]["id"]
     title = get_session_title(sessions[idx])
     print(_("export.interactive_exporting", title=title))
-    session_info = get_session_info(db, session_id)
+    try:
+        session_info = get_session_info(db, session_id)
+    except SessionError as e:
+        print(e.message)
+        return 1
     return _do_export(db, session_info, output_dir, force, note, full)
 
 
-def _do_export(db, session_info, output_dir, force, note, full=False) -> Literal[1] | Literal[0]:
+def _do_export(db, session_info, output_dir, force, note, full=False) -> int:
     """Внутренняя функция: экспорт диалога."""
     title = get_session_title(session_info)
     model = parse_model(session_info)
@@ -176,7 +188,7 @@ def _do_export(db, session_info, output_dir, force, note, full=False) -> Literal
     return 0
 
 
-def run(args, db) -> Literal[1] | Literal[0]:
+def run(args, db) -> int:
     output_dir = args.output or os.getcwd()
     full = args.full
 

{opencode_db-0.4.7 → opencode_db-0.4.9}/cmd_info.py

@@ -1,9 +1,7 @@
 """Команда info: детальная информация о сессии."""
 
-# import db as db_module
-from typing import Literal
-
 from db import (
+    SessionError,
     get_children_sessions,
     get_message_count,
     get_parent_session,
@@ -24,8 +22,12 @@ def register(subparsers) -> None:
     p.add_argument("--json", action="store_true", help="JSON output")
 
 
-def run(args, db) -> Literal[0]:
-    info = get_session_info(db, args.session_id)
+def run(args, db) -> int:
+    try:
+        info = get_session_info(db, args.session_id)
+    except SessionError as e:
+        print(e.message)
+        return 1
     session_id = info["id"]
     msg_count = get_message_count(db, session_id)
     part_count = get_part_count(db, session_id)

{opencode_db-0.4.7 → opencode_db-0.4.9}/cmd_search.py

@@ -1,9 +1,8 @@
 """Команда search: поиск по тексту сообщений и частей."""
 
 import json
-from typing import Literal
 
-from db import resolve_session_id
+from db import SessionError, resolve_session_id
 from i18n import _
 from utils import format_ts
 
@@ -16,9 +15,7 @@ def register(subparsers) -> None:
     p.add_argument("--json", action="store_true", help="JSON output")
 
 
-def _search_in_part_data(
-    data, query_lower
-) -> tuple[Literal[False], Literal[""]] | tuple[Literal[True], str]:
+def _search_in_part_data(data, query_lower) -> tuple[bool, str]:
     """Ищет query в part.data (JSON), проверяя текстовые поля."""
     if not data:
         return False, ""
@@ -45,14 +42,18 @@ def _search_in_part_data(
     return False, ""
 
 
-def run(args, db) -> Literal[0]:
+def run(args, db) -> int:
     query_lower = args.query.lower()
 
     conditions = []
     params = []
 
     if args.session:
-        full_id = resolve_session_id(db, args.session)
+        try:
+            full_id = resolve_session_id(db, args.session)
+        except SessionError as e:
+            print(e.message)
+            return 1
         conditions.append("p.session_id = ?")
         params.append(full_id)
 

{opencode_db-0.4.7 → opencode_db-0.4.9}/cmd_todos.py

@@ -1,8 +1,6 @@
 """Команда todos: просмотр задач (todo) из сессий."""
 
-from typing import Literal
-
-from db import resolve_session_id
+from db import SessionError, resolve_session_id
 from i18n import _
 from utils import format_ts
 
@@ -19,12 +17,16 @@ def register(subparsers) -> None:
     p.add_argument("--json", action="store_true", help="JSON output")
 
 
-def run(args, db) -> Literal[0]:
+def run(args, db) -> int:
     conditions = []
     params = []
 
     if args.session_id:
-        full_id = resolve_session_id(db, args.session_id)
+        try:
+            full_id = resolve_session_id(db, args.session_id)
+        except SessionError as e:
+            print(e.message)
+            return 1
         conditions.append("t.session_id = ?")
         params.append(full_id)
 

{opencode_db-0.4.7 → opencode_db-0.4.9}/cmd_tree.py

@@ -1,8 +1,6 @@
 """Команда tree: дерево ветвления сессий."""
 
-from typing import Literal
-
-from db import get_session_title, resolve_session_id
+from db import SessionError, get_session_title, resolve_session_id
 from i18n import _
 from utils import format_ts
 
@@ -55,9 +53,13 @@ def _build_tree(db, parent_id, depth, max_depth, indent=0, visited=None):
     return lines
 
 
-def run(args, db) -> Literal[0]:
+def run(args, db) -> int:
     if args.session_id:
-        full_id = resolve_session_id(db, args.session_id)
+        try:
+            full_id = resolve_session_id(db, args.session_id)
+        except SessionError as e:
+            print(e.message)
+            return 1
         info = db.execute(
             "SELECT id, title, time_created FROM session WHERE id = ?", (full_id,)
         ).fetchone()

{opencode_db-0.4.7 → opencode_db-0.4.9}/db.py

@@ -15,6 +15,15 @@ import sys
 from config import OPENCODE_DB
 from i18n import _
 
+
+class SessionError(Exception):
+    """Ошибка, связанная с сессией: не найдена, неоднозначный ID и т.п."""
+
+    def __init__(self, message: str):
+        self.message = message
+        super().__init__(message)
+
+
 # Ожидаемая схема БД: таблица → список обязательных колонок
 _EXPECTED_SCHEMA = {
     "session": [
@@ -95,15 +104,14 @@ def resolve_session_id(db, session_id):
     ).fetchall()
 
     if not rows:
-        print(_("session.not_found", session_id=session_id))
-        sys.exit(1)
+        raise SessionError(_("session.not_found", session_id=session_id))
 
     if len(rows) > 1:
-        print(_("session.multiple_match", session_id=session_id))
+        msg = [_("session.multiple_match", session_id=session_id)]
         for r in rows:
-            print(f"    {r['id']}")
-        print(_("session.specify_id"))
-        sys.exit(1)
+            msg.append(f"    {r['id']}")
+        msg.append(_("session.specify_id"))
+        raise SessionError("\n".join(msg))
 
     return rows[0]["id"]
 
@@ -127,8 +135,7 @@ def get_session_info(db, session_id):
     ).fetchone()
 
     if not row:
-        print(_("session.not_found", session_id=session_id))
-        sys.exit(1)
+        raise SessionError(_("session.not_found", session_id=session_id))
 
     return row
 
@@ -338,8 +345,7 @@ def get_latest_session(db):
     """).fetchone()
 
     if not row:
-        print(_("session.no_sessions"))
-        sys.exit(1)
+        raise SessionError(_("session.no_sessions"))
 
     return row["id"]
 

{opencode_db-0.4.7 → opencode_db-0.4.9/opencode_db.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: opencode-db
-Version: 0.4.7
+Version: 0.4.9
 Summary: OpenCode database CLI manager — browse, export, analyze, clean up sessions
 Project-URL: Homepage, https://github.com/VasilevNStas/opencode-db
 Project-URL: Source, https://github.com/VasilevNStas/opencode-db

{opencode_db-0.4.7 → opencode_db-0.4.9}/opencode_db.egg-info/SOURCES.txt

@@ -29,5 +29,6 @@ opencode_db.egg-info/entry_points.txt
 opencode_db.egg-info/top_level.txt
 tests/test_commands.py
 tests/test_db.py
+tests/test_formatters.py
 tests/test_i18n.py
 tests/test_utils.py

{opencode_db-0.4.7 → opencode_db-0.4.9}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "opencode-db"
-version = "0.4.7"
+version = "0.4.9"
 description = "OpenCode database CLI manager — browse, export, analyze, clean up sessions"
 readme = "README_PYPI.md"
 requires-python = ">=3.12"

{opencode_db-0.4.7 → opencode_db-0.4.9}/tests/test_commands.py

@@ -6,6 +6,18 @@ def _ns(**kwargs) -> argparse.Namespace:
     return argparse.Namespace(**kwargs)
 
 
+def _count_sessions(db) -> int:
+    return db.execute("SELECT COUNT(*) FROM session").fetchone()[0]
+
+
+def _count_messages(db) -> int:
+    return db.execute("SELECT COUNT(*) FROM message").fetchone()[0]
+
+
+def _count_parts(db) -> int:
+    return db.execute("SELECT COUNT(*) FROM part").fetchone()[0]
+
+
 class TestListCommand:
     def test_list_default(self, db):
         from cmd_list import run
@@ -418,3 +430,80 @@ class TestExportCommand:
             output=str(tmp_path),
         )
         assert run(args, db) == 0
+
+
+class TestPruneCommand:
+    def test_prune_filter_required(self, db) -> None:
+        from cmd_prune import run
+
+        args = _ns(older_than=None, keep_last=None, project=None, dry_run=False, force=False)
+        assert run(args, db) == 1
+
+    def test_prune_dry_run_older_than(self, db) -> None:
+        from cmd_prune import run
+
+        args = _ns(older_than="30d", keep_last=None, project=None, dry_run=True, force=True)
+        assert run(args, db) == 0
+
+    def test_prune_dry_run_keep_last(self, db) -> None:
+        from cmd_prune import run
+
+        args = _ns(older_than=None, keep_last=2, project=None, dry_run=True, force=True)
+        assert run(args, db) == 0
+        assert _count_sessions(db) == 4
+
+    def test_prune_force_older_than(self, db) -> None:
+        from cmd_prune import run
+
+        args = _ns(older_than="1d", keep_last=None, project=None, dry_run=False, force=True)
+        result = run(args, db)
+        assert result == 0
+        remaining = _count_sessions(db)
+        assert remaining < 4
+
+    def test_prune_by_project(self, db) -> None:
+        from cmd_prune import run
+
+        args = _ns(older_than=None, keep_last=None, project="proj_002", dry_run=True, force=True)
+        assert run(args, db) == 0
+
+    def test_prune_bad_spec(self, db) -> None:
+        from cmd_prune import run
+
+        args = _ns(older_than="invalid", keep_last=None, project=None, dry_run=False, force=True)
+        assert run(args, db) == 1
+
+    def test_prune_canceled(self, db) -> None:
+        from cmd_prune import run
+
+        args = _ns(older_than="30d", keep_last=None, project=None, dry_run=False, force=False)
+        with patch("cmd_prune.confirm", return_value=False):
+            assert run(args, db) == 0
+        assert _count_sessions(db) == 4
+
+    def test_prune_deletes_messages_and_parts(self, db) -> None:
+        from cmd_prune import run
+
+        total_msg = _count_messages(db)
+        total_parts = _count_parts(db)
+        assert total_msg > 0
+        assert total_parts > 0
+
+        args = _ns(older_than="1d", keep_last=None, project=None, dry_run=False, force=True)
+        assert run(args, db) == 0
+
+        assert _count_messages(db) < total_msg
+        assert _count_parts(db) < total_parts
+
+    def test_prune_keep_last_preserves_recent(self, db) -> None:
+        from cmd_prune import run
+
+        args = _ns(older_than=None, keep_last=10, project=None, dry_run=True, force=True)
+        assert run(args, db) == 0
+
+    def test_prune_none_to_delete(self, db) -> None:
+        from cmd_prune import run
+
+        args = _ns(older_than="100y", keep_last=None, project=None, dry_run=False, force=True)
+        assert run(args, db) == 0
+        assert _count_sessions(db) == 4

{opencode_db-0.4.7 → opencode_db-0.4.9}/tests/test_db.py

@@ -1,7 +1,13 @@
+import json
+
+import pytest
+
 from db import (
+    SessionError,
     get_children_sessions,
     get_latest_session,
     get_message_count,
+    get_messages,
     get_parent_session,
     get_part_count,
     get_project_count,
@@ -12,6 +18,7 @@ from db import (
     get_session_title,
     get_session_todos,
     parse_model,
+    resolve_session_id,
     verify_schema,
 )
 
@@ -150,3 +157,121 @@ class TestGetRecentSessions:
     def test_custom_limit(self, db) -> None:
         sessions = get_recent_sessions(db, limit=2)
         assert len(sessions) == 2
+
+
+class TestResolveSessionId:
+    def test_empty_id_returns_none(self, db) -> None:
+        assert resolve_session_id(db, None) is None
+        assert resolve_session_id(db, "") is None
+
+
+class TestSessionError:
+    def test_resolve_session_id_not_found(self, db) -> None:
+        with pytest.raises(SessionError):
+            get_session_info(db, "nonexistent")
+
+    def test_resolve_session_id_multiple(self, db) -> None:
+        db.execute(
+            "INSERT INTO session (id, time_created) VALUES (?, ?)",
+            ("ses_test_abc", 1000),
+        )
+        db.execute(
+            "INSERT INTO session (id, time_created) VALUES (?, ?)",
+            ("ses_test_xyz", 2000),
+        )
+        db.commit()
+        with pytest.raises(SessionError):
+            get_session_info(db, "ses_test")
+
+    def test_get_latest_session_no_sessions(self, db) -> None:
+        db.execute("DELETE FROM session")
+        db.commit()
+        with pytest.raises(SessionError):
+            get_latest_session(db)
+
+    def test_get_session_info_not_found(self, db) -> None:
+        with pytest.raises(SessionError):
+            get_session_info(db, "zzz_nope")
+
+
+class TestGetMessages:
+    def test_returns_messages_with_parts(self, db) -> None:
+        messages = get_messages(db, "ses_001")
+        assert len(messages) == 2
+        assert messages[0]["role"] == "user"
+        assert messages[1]["role"] == "assistant"
+
+    def test_parts_are_grouped_by_message(self, db) -> None:
+        messages = get_messages(db, "ses_001")
+        assert len(messages) == 2
+        assert len(messages[0]["parts"]) == 1
+        assert messages[0]["parts"][0]["type"] == "text"
+
+    def test_multiple_parts_per_message(self, db) -> None:
+        messages = get_messages(db, "ses_001")
+        parts = messages[1]["parts"]
+        assert len(parts) == 3
+        types = [p["type"] for p in parts]
+        assert types == ["text", "reasoning", "tool"]
+
+    def test_text_part_content(self, db) -> None:
+        messages = get_messages(db, "ses_001")
+        text_part = messages[0]["parts"][0]
+        assert text_part["type"] == "text"
+        assert "Hello" in text_part["text"]
+
+    def test_reasoning_part(self, db) -> None:
+        messages = get_messages(db, "ses_001")
+        parts = messages[1]["parts"]
+        reasoning = [p for p in parts if p["type"] == "reasoning"]
+        assert len(reasoning) == 1
+        assert "think" in reasoning[0]["text"].lower()
+
+    def test_tool_part(self, db) -> None:
+        messages = get_messages(db, "ses_001")
+        parts = messages[1]["parts"]
+        tool = [p for p in parts if p["type"] == "tool"]
+        assert len(tool) == 1
+        assert tool[0]["tool"] == "read"
+        assert tool[0]["status"] == "completed"
+
+    def test_sound_part(self, db) -> None:
+        messages = get_messages(db, "ses_003")
+        assert len(messages) == 2
+        parts = messages[0]["parts"]
+        assert len(parts) == 1
+        assert parts[0]["type"] == "sound"
+
+    def test_empty_session(self, db) -> None:
+        messages = get_messages(db, "ses_004")
+        assert messages == []
+
+    def test_bash_tool_part(self, db) -> None:
+        messages = get_messages(db, "ses_003")
+        tool_part = messages[1]["parts"][0]
+        assert tool_part["type"] == "tool"
+        assert tool_part["tool"] == "bash"
+
+    def test_skips_invalid_json_part(self, db) -> None:
+        db.execute(
+            "INSERT INTO message (id, session_id, time_created, data) VALUES (?, ?, ?, ?)",
+            ("msg_bad", "ses_001", 100500, json.dumps({"role": "user"})),
+        )
+        db.execute(
+            "INSERT INTO part (id, message_id, session_id, time_created, data) VALUES (?, ?, ?, ?, ?)",
+            ("part_bad", "msg_bad", "ses_001", 100500, "not valid json {"),
+        )
+        messages = get_messages(db, "ses_001")
+        assert len(messages) == 2
+
+    def test_skips_empty_part_data(self, db) -> None:
+        db.execute(
+            "INSERT INTO message (id, session_id, time_created, data) VALUES (?, ?, ?, ?)",
+            ("msg_empty", "ses_001", 100600, json.dumps({"role": "user"})),
+        )
+        db.execute(
+            "INSERT INTO part (id, message_id, session_id, time_created, data) VALUES (?, ?, ?, ?, ?)",
+            ("part_empty", "msg_empty", "ses_001", 100600, None),
+        )
+        messages = get_messages(db, "ses_001")
+        assert len(messages) == 2

opencode_db-0.4.9/tests/test_formatters.py

@@ -0,0 +1,173 @@
+from formatters import format_part_to_md
+
+
+class TestFormatPartToMd:
+    def test_text_part(self):
+        result = format_part_to_md({"type": "text", "text": "Hello world"})
+        assert result == "Hello world"
+
+    def test_text_part_strips_whitespace(self):
+        result = format_part_to_md({"type": "text", "text": "  hello  "})
+        assert result == "hello"
+
+    def test_text_part_empty_returns_empty(self):
+        result = format_part_to_md({"type": "text", "text": ""})
+        assert result == ""
+
+    def test_text_part_missing_text(self):
+        result = format_part_to_md({"type": "text"})
+        assert result == ""
+
+    def test_reasoning_part(self):
+        result = format_part_to_md({"type": "reasoning", "text": "Let me think..."})
+        assert "Let me think..." in result
+        assert "reasoning" in result.lower() or "💭" in result
+
+    def test_reasoning_empty_returns_empty(self):
+        result = format_part_to_md({"type": "reasoning", "text": "   "})
+        assert result == ""
+
+    def test_sound_part(self):
+        result = format_part_to_md({"type": "sound"})
+        assert result != ""
+
+    def test_tool_read_part(self):
+        result = format_part_to_md(
+            {
+                "type": "tool",
+                "tool": "read",
+                "input": {"filePath": "/home/user/file.py"},
+                "output": "content",
+                "status": "completed",
+            }
+        )
+        assert "read" in result
+        assert "file.py" in result
+
+    def test_tool_write_part(self):
+        result = format_part_to_md(
+            {
+                "type": "tool",
+                "tool": "write",
+                "input": {"filePath": "/home/user/new.py"},
+                "output": "",
+                "status": "completed",
+            }
+        )
+        assert "write" in result
+
+    def test_tool_edit_part(self):
+        result = format_part_to_md(
+            {
+                "type": "tool",
+                "tool": "edit",
+                "input": {"filePath": "/home/user/file.py"},
+                "output": "",
+                "status": "completed",
+            }
+        )
+        assert "edit" in result
+
+    def test_tool_glob_part(self):
+        result = format_part_to_md(
+            {
+                "type": "tool",
+                "tool": "glob",
+                "input": {"pattern": "**/*.py", "path": "/home/user"},
+                "output": "",
+                "status": "completed",
+            }
+        )
+        assert "glob" in result
+        assert "**/*.py" in result
+
+    def test_tool_grep_part(self):
+        result = format_part_to_md(
+            {
+                "type": "tool",
+                "tool": "grep",
+                "input": {"pattern": "def hello"},
+                "output": "def hello():\n    pass",
+                "status": "completed",
+            }
+        )
+        assert "grep" in result
+        assert "def hello" in result
+
+    def test_tool_custom_with_input_output(self):
+        result = format_part_to_md(
+            {
+                "type": "tool",
+                "tool": "bash",
+                "input": {"command": "ls -la"},
+                "output": "total 42\n-rw-r--r-- 1 user staff 1234 Jan 1 00:00 file.py",
+                "status": "completed",
+            }
+        )
+        assert "bash" in result
+        assert "ls -la" in result
+        assert "total 42" in result
+
+    def test_tool_error_status(self):
+        result = format_part_to_md(
+            {
+                "type": "tool",
+                "tool": "bash",
+                "input": {"command": "rm -rf /"},
+                "output": "permission denied",
+                "status": "error",
+            }
+        )
+        assert "❌" in result
+
+    def test_tool_running_status(self):
+        result = format_part_to_md(
+            {
+                "type": "tool",
+                "tool": "bash",
+                "input": {"command": "sleep 10"},
+                "output": "",
+                "status": "running",
+            }
+        )
+        assert "⏳" in result
+
+    def test_tool_no_output(self):
+        result = format_part_to_md(
+            {
+                "type": "tool",
+                "tool": "bash",
+                "input": {"command": "echo hi"},
+                "output": "",
+                "status": "completed",
+            }
+        )
+        assert "echo hi" in result
+
+    def test_full_mode_does_not_truncate_path(self):
+        long_path = "/a/" + "very/" * 50 + "file.py"
+        result = format_part_to_md(
+            {
+                "type": "tool",
+                "tool": "read",
+                "input": {"filePath": long_path},
+                "output": "",
+                "status": "completed",
+            },
+            full=True,
+        )
+        assert long_path in result
+        assert "..." not in result
+
+    def test_full_mode_shows_full_output(self):
+        result = format_part_to_md(
+            {
+                "type": "tool",
+                "tool": "bash",
+                "input": {"command": "cat bigfile.txt"},
+                "output": "line\n" * 500,
+                "status": "completed",
+            },
+            full=True,
+        )
+        assert "line" in result