jvim 0.6.0__tar.gz → 0.7.0__tar.gz

{jvim-0.6.0 → jvim-0.7.0}/.claude/CLAUDE.md

@@ -1,6 +1,7 @@
 
 키 바인딩이 추가되면 help.json 파일을 업데이트한다.
 푸시할 때 버전의 업그레이드 여부를 분석해서 보고한다.
+푸시할 때 변경 사항에 대해 위키를 업데이트한다.
 버전이 업그레이드되는 경우 README.md 파일에 추가할 만한 항목을 분석한다.
 README.md 파일이 수정되면 README.kr.md 파일도 동일한 내용으로 수정한다.
 jvim에 적용되는 기능 중에서 jvimdiff에도 적용 가능한 기능은 적용 여부를 확인한다.

{jvim-0.6.0 → jvim-0.7.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: jvim
-Version: 0.6.0
+Version: 0.7.0
 Summary: JSON editor with vim-style keybindings
 Project-URL: Homepage, https://github.com/k2hyun/jvim
 Project-URL: Repository, https://github.com/k2hyun/jvim
@@ -50,6 +50,7 @@ JSON editor with vim-style keybindings, built with [Textual](https://github.com/
 - **JSONL support** - Edit JSON Lines files with smart formatting
 - **Embedded JSON editing** - Edit JSON strings within JSON with nested level support
 - **Visual mode** - Character-wise (`v`) and line-wise (`V`) selection with `d`/`y`/`c` operators
+- **Count prefix** - Vim-style numeric prefixes (`5j`, `3dd`, `d3d`) with fold-aware line operations
 - **Folding** - Collapse/expand JSON blocks and long string values
 - **Bracket matching** - Jump to matching brackets with `%`
 - **Undo/Redo** - Full undo history

{jvim-0.6.0 → jvim-0.7.0}/README.kr.md

@@ -19,6 +19,7 @@
 - **JSONL 지원** - JSON Lines 파일을 스마트하게 포맷팅하여 편집
 - **내장 JSON 편집** - JSON 내 문자열로 저장된 JSON을 중첩 레벨까지 편집
 - **Visual 모드** - 문자 단위(`v`) 및 줄 단위(`V`) 선택 후 `d`/`y`/`c` 연산자 지원
+- **숫자 접두사(Count prefix)** - Vim 스타일 숫자 접두사(`5j`, `3dd`, `d3d`) 및 fold-aware 줄 조작
 - **접기(Folding)** - JSON 블록과 긴 문자열 값을 접기/펼치기
 - **괄호 매칭** - `%`로 짝이 맞는 괄호로 이동
 - **Undo/Redo** - 전체 실행 취소 기록 지원

{jvim-0.6.0 → jvim-0.7.0}/README.md

@@ -21,6 +21,7 @@ JSON editor with vim-style keybindings, built with [Textual](https://github.com/
 - **JSONL support** - Edit JSON Lines files with smart formatting
 - **Embedded JSON editing** - Edit JSON strings within JSON with nested level support
 - **Visual mode** - Character-wise (`v`) and line-wise (`V`) selection with `d`/`y`/`c` operators
+- **Count prefix** - Vim-style numeric prefixes (`5j`, `3dd`, `d3d`) with fold-aware line operations
 - **Folding** - Collapse/expand JSON blocks and long string values
 - **Bracket matching** - Jump to matching brackets with `%`
 - **Undo/Redo** - Full undo history

{jvim-0.6.0 → jvim-0.7.0}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "hatchling.build"
 
 [project]
 name = "jvim"
-version = "0.6.0"
+version = "0.7.0"
 description = "JSON editor with vim-style keybindings"
 readme = "README.md"
 requires-python = ">=3.10"

{jvim-0.6.0 → jvim-0.7.0}/src/jvim/__init__.py

@@ -3,4 +3,4 @@
 from .widget import EditorMode, JsonEditor
 
 __all__ = ["EditorMode", "JsonEditor"]
-__version__ = "0.6.0"
+__version__ = "0.7.0"

{jvim-0.6.0 → jvim-0.7.0}/src/jvim/action/clipboard.py

@@ -45,11 +45,16 @@ class ClipboardMixin:
                 self.cursor_row += inserted
                 self.cursor_col = len(parts[-1]) - 1
             return
+        # fold-aware: fold 헤더이면 fold end 뒤에 삽입
+        insert_after = self.cursor_row
+        fold_end = self._folds.get(self.cursor_row)
+        if fold_end is not None:
+            insert_after = fold_end
         inserted = len(self.yank_buffer)
         for i, line in enumerate(self.yank_buffer):
-            self.lines.insert(self.cursor_row + 1 + i, line)
-        self._adjust_line_indices(self.cursor_row + 1, inserted)
-        self.cursor_row += 1
+            self.lines.insert(insert_after + 1 + i, line)
+        self._adjust_line_indices(insert_after + 1, inserted)
+        self.cursor_row = insert_after + 1
         self.cursor_col = 0
 
     def _paste_before(self) -> None:
@@ -88,11 +93,33 @@ class ClipboardMixin:
     def _join_lines(self) -> None:
         if self.cursor_row >= len(self.lines) - 1:
             return
-        self._save_undo()
-        cur = self.lines[self.cursor_row].rstrip()
-        nxt = self.lines[self.cursor_row + 1].lstrip()
-        self.cursor_col = len(cur)
-        self.lines[self.cursor_row] = cur + " " + nxt
-        deleted_at = self.cursor_row + 1
-        self.lines.pop(deleted_at)
-        self._adjust_line_indices(deleted_at, -1)
+        # fold-aware: fold 헤더이면 fold 전체를 제거한 뒤 다음 보이는 줄과 join
+        fold_end = self._folds.get(self.cursor_row)
+        if fold_end is not None:
+            next_row = fold_end + 1
+            if next_row >= len(self.lines):
+                return
+            self._save_undo()
+            cur = self.lines[self.cursor_row].rstrip()
+            # fold 내부 행 제거 (cursor_row+1 ~ fold_end)
+            del self.lines[self.cursor_row + 1 : next_row]
+            removed = fold_end - self.cursor_row
+            del self._folds[self.cursor_row]
+            self._folded_lines_dirty = True
+            self._adjust_line_indices(self.cursor_row + 1, -removed)
+            # 이제 cursor_row+1 = 원래 next_row (fold 뒤 첫 줄)
+            nxt = self.lines[self.cursor_row + 1].lstrip()
+            self.cursor_col = len(cur)
+            self.lines[self.cursor_row] = cur + " " + nxt
+            deleted_at = self.cursor_row + 1
+            self.lines.pop(deleted_at)
+            self._adjust_line_indices(deleted_at, -1)
+        else:
+            self._save_undo()
+            cur = self.lines[self.cursor_row].rstrip()
+            nxt = self.lines[self.cursor_row + 1].lstrip()
+            self.cursor_col = len(cur)
+            self.lines[self.cursor_row] = cur + " " + nxt
+            deleted_at = self.cursor_row + 1
+            self.lines.pop(deleted_at)
+            self._adjust_line_indices(deleted_at, -1)

{jvim-0.6.0 → jvim-0.7.0}/src/jvim/data/help.json

@@ -1,4 +1,14 @@
 {
+    "Count Prefix": {
+        "{N}motion": "repeat motion N times (e.g., 5j)",
+        "{N}G": "go to line N",
+        "{N}dd": "delete N lines (fold-aware)",
+        "{N}yy": "yank N lines (fold-aware)",
+        "d{N}d": "delete N lines (e.g., d3d)",
+        "{N}x": "delete N chars",
+        "{N}p {N}P": "paste N times",
+        "{N}J": "join N times"
+    },
     "Movement": {
         "h j k l": "left/down/up/right",
         "w b": "word forward/backward",

{jvim-0.6.0 → jvim-0.7.0}/src/jvim/mode/normal.py

@@ -14,23 +14,40 @@ class NormalMixin:
         self._mode = EditorMode.INSERT
         self.status_msg = "-- INSERT --"
 
+    def _consume_count(self) -> int:
+        """_count_buf를 소비하고 정수 반환. 비어 있으면 1."""
+        if self._count_buf:
+            n = int(self._count_buf)
+            self._count_buf = ""
+            return max(1, n)
+        return 1
+
     def _handle_normal(self, event) -> None:
         EditorMode = self._mode.__class__
         key = event.key
         char = event.character or ""
 
-        # Escape: visual mode 해제 (pending보다 우선)
-        if key == "escape" and self._visual_mode:
-            self._visual_mode = ""
-            self.status_msg = ""
+        # Escape: visual mode 해제 (pending보다 우선) + count 리셋
+        if key == "escape":
+            self._count_buf = ""
+            if self._visual_mode:
+                self._visual_mode = ""
+                self.status_msg = ""
             return
 
         if self.pending:
             self._handle_pending(char, key)
             return
 
+        # 숫자 접두사 수집: 1-9로 시작, 이후 0-9 누적
+        if char and char.isdigit():
+            if char != "0" or self._count_buf:
+                self._count_buf += char
+                return
+
         # Visual mode 진입/전환/해제
         if char == "v":
+            self._count_buf = ""
             if self._visual_mode == "v":
                 self._visual_mode = ""
                 self.status_msg = ""
@@ -41,6 +58,7 @@ class NormalMixin:
                 self.status_msg = "-- VISUAL --"
             return
         if char == "V":
+            self._count_buf = ""
             if self._visual_mode == "V":
                 self._visual_mode = ""
                 self.status_msg = ""
@@ -51,40 +69,61 @@ class NormalMixin:
                 self.status_msg = "-- VISUAL LINE --"
             return
 
-        # movement
+        # movement (count 적용)
         if char == "h" or key == "left":
-            self.cursor_col -= 1
+            count = self._consume_count()
+            self.cursor_col -= count
         elif char == "j" or key == "down":
-            self.cursor_row = (
-                self._next_visible_line(self.cursor_row, 1)
-                if self._folds
-                else self.cursor_row + 1
-            )
+            count = self._consume_count()
+            for _ in range(count):
+                self.cursor_row = (
+                    self._next_visible_line(self.cursor_row, 1)
+                    if self._folds
+                    else self.cursor_row + 1
+                )
         elif char == "k" or key == "up":
-            self.cursor_row = (
-                self._next_visible_line(self.cursor_row, -1)
-                if self._folds
-                else self.cursor_row - 1
-            )
+            count = self._consume_count()
+            for _ in range(count):
+                self.cursor_row = (
+                    self._next_visible_line(self.cursor_row, -1)
+                    if self._folds
+                    else self.cursor_row - 1
+                )
         elif char == "l" or key == "right":
-            self.cursor_col += 1
+            count = self._consume_count()
+            self.cursor_col += count
         elif char == "w":
-            self._move_word_forward()
+            count = self._consume_count()
+            for _ in range(count):
+                self._move_word_forward()
         elif char == "b":
-            self._move_word_backward()
+            count = self._consume_count()
+            for _ in range(count):
+                self._move_word_backward()
         elif char == "0":
+            # bare 0 (count_buf가 비었을 때만 여기 도달)
             self.cursor_col = 0
         elif char == "$" or key == "end":
+            self._count_buf = ""
             self.cursor_col = max(0, len(self.lines[self.cursor_row]) - 1)
         elif char == "^" or key == "home":
+            self._count_buf = ""
             line = self.lines[self.cursor_row]
             self.cursor_col = len(line) - len(line.lstrip())
         elif char == "G":
-            self.cursor_row = len(self.lines) - 1
+            if self._count_buf:
+                # count가 있으면 해당 줄로 이동 (1-indexed)
+                count = self._consume_count()
+                self.cursor_row = count - 1
+            else:
+                # count 없으면 마지막 줄
+                self.cursor_row = len(self.lines) - 1
             self._scroll_cursor_to_top()
         elif char == "%":
+            self._count_buf = ""
             self._jump_matching_bracket()
         elif key == "pagedown" or key == "ctrl+f":
+            self._count_buf = ""
             if self._folds:
                 self.cursor_row = self._skip_visible_lines(
                     self.cursor_row, self._visible_height(), 1
@@ -92,6 +131,7 @@ class NormalMixin:
             else:
                 self.cursor_row += self._visible_height()
         elif key == "pageup" or key == "ctrl+b":
+            self._count_buf = ""
             if self._folds:
                 self.cursor_row = self._skip_visible_lines(
                     self.cursor_row, self._visible_height(), -1
@@ -99,6 +139,7 @@ class NormalMixin:
             else:
                 self.cursor_row -= self._visible_height()
         elif key == "ctrl+d":
+            self._count_buf = ""
             if self._folds:
                 self.cursor_row = self._skip_visible_lines(
                     self.cursor_row, self._visible_height() // 2, 1
@@ -106,6 +147,7 @@ class NormalMixin:
             else:
                 self.cursor_row += self._visible_height() // 2
         elif key == "ctrl+u":
+            self._count_buf = ""
             if self._folds:
                 self.cursor_row = self._skip_visible_lines(
                     self.cursor_row, self._visible_height() // 2, -1
@@ -113,6 +155,7 @@ class NormalMixin:
             else:
                 self.cursor_row -= self._visible_height() // 2
         elif key == "ctrl+e":
+            self._count_buf = ""
             nxt = (
                 self._next_visible_line(self._scroll_top, 1)
                 if self._folds
@@ -120,6 +163,7 @@ class NormalMixin:
             )
             self._scroll_top = min(nxt, len(self.lines) - 1)
         elif key == "ctrl+y":
+            self._count_buf = ""
             prev = (
                 self._next_visible_line(self._scroll_top, -1)
                 if self._folds
@@ -127,6 +171,7 @@ class NormalMixin:
             )
             self._scroll_top = max(prev, 0)
         elif key == "ctrl+g":
+            self._count_buf = ""
             total = len(self.lines)
             pct = (self.cursor_row + 1) * 100 // total if total else 0
             self.status_msg = (
@@ -135,40 +180,60 @@ class NormalMixin:
 
         # enter insert mode
         elif char == "i":
+            self._count_buf = ""
             if not self.read_only:
                 self._dot_start(event)
             self._enter_insert()
         elif char == "I":
+            self._count_buf = ""
             if not self.read_only:
                 self._dot_start(event)
             line = self.lines[self.cursor_row]
             self.cursor_col = len(line) - len(line.lstrip())
             self._enter_insert()
         elif char == "a":
+            self._count_buf = ""
             if not self.read_only:
                 self._dot_start(event)
             self.cursor_col += 1
             self._enter_insert()
         elif char == "A":
+            self._count_buf = ""
             if not self.read_only:
                 self._dot_start(event)
             self.cursor_col = len(self.lines[self.cursor_row])
             self._enter_insert()
         elif char == "o":
+            self._count_buf = ""
             if self.read_only:
                 self.status_msg = "[readonly]"
             else:
                 self._dot_start(event)
                 self._save_undo()
-                indent = self._current_indent()
-                before = self.lines[self.cursor_row].rstrip()
-                extra = "    " if before.endswith(("{", "[")) else ""
-                self.cursor_row += 1
+                # fold-aware: fold 헤더이면 fold end 뒤에 삽입
+                fold_end = self._folds.get(self.cursor_row)
+                if fold_end is not None:
+                    insert_row = fold_end + 1
+                    # fold end 행의 들여쓰기 기준
+                    end_line = self.lines[fold_end]
+                    indent = (
+                        len(end_line) - len(end_line.lstrip())
+                        if end_line.strip()
+                        else 0
+                    )
+                    extra = ""
+                else:
+                    insert_row = self.cursor_row + 1
+                    indent = self._current_indent()
+                    before = self.lines[self.cursor_row].rstrip()
+                    extra = "    " if before.endswith(("{", "[")) else ""
+                self.cursor_row = insert_row
                 self.lines.insert(self.cursor_row, " " * indent + extra)
                 self._adjust_line_indices(self.cursor_row, 1)
                 self.cursor_col = indent + len(extra)
                 self._enter_insert()
         elif char == "O":
+            self._count_buf = ""
             if self.read_only:
                 self.status_msg = "[readonly]"
             else:
@@ -180,63 +245,78 @@ class NormalMixin:
                 self.cursor_col = indent
                 self._enter_insert()
 
-        # single-key edits
+        # single-key edits (count 적용)
         elif char == "x":
             if self.read_only:
+                self._count_buf = ""
                 self.status_msg = "[readonly]"
             else:
+                count = self._consume_count()
                 self._dot_start(event)
                 self._dot_stop()
                 self._save_undo()
                 line = self.lines[self.cursor_row]
                 if line and self.cursor_col < len(line):
-                    self.lines[self.cursor_row] = (
-                        line[: self.cursor_col] + line[self.cursor_col + 1 :]
-                    )
+                    end = min(self.cursor_col + count, len(line))
+                    self.lines[self.cursor_row] = line[: self.cursor_col] + line[end:]
         elif char == "p":
             if self.read_only:
+                self._count_buf = ""
                 self.status_msg = "[readonly]"
             else:
+                count = self._consume_count()
                 self._dot_start(event)
                 self._dot_stop()
-                self._paste_after()
+                for _ in range(count):
+                    self._paste_after()
         elif char == "P":
             if self.read_only:
+                self._count_buf = ""
                 self.status_msg = "[readonly]"
             else:
+                count = self._consume_count()
                 self._dot_start(event)
                 self._dot_stop()
-                self._paste_before()
+                for _ in range(count):
+                    self._paste_before()
         elif char == "u":
+            self._count_buf = ""
             if self.read_only:
                 self.status_msg = "[readonly]"
             else:
                 self._undo()
         elif key == "ctrl+r":
+            self._count_buf = ""
             if self.read_only:
                 self.status_msg = "[readonly]"
             else:
                 self._redo()
         elif char == "J":
             if self.read_only:
+                self._count_buf = ""
                 self.status_msg = "[readonly]"
             else:
+                count = self._consume_count()
                 self._dot_start(event)
                 self._dot_stop()
-                self._join_lines()
+                for _ in range(count):
+                    self._join_lines()
 
         # dot repeat
         elif char == ".":
+            self._count_buf = ""
             if not self.read_only:
                 self._dot_replay()
 
-        # multi-key starters
+        # multi-key starters (count는 pending에서 계속 누적 가능)
         elif char in ("d", "c", "y", "r", "g", "e", "z"):
             # Visual mode 연산자 인터셉트
             if self._visual_mode and char in ("d", "y", "c"):
+                self._count_buf = ""
                 self._execute_visual_operator(char)
                 return
             if self.read_only and char not in ("y", "g", "e", "z"):
+                self._count_buf = ""
                 self.status_msg = "[readonly]"
             else:
                 if char not in ("y", "g", "e", "z"):
@@ -245,24 +325,29 @@ class NormalMixin:
 
         # search mode
         elif char == "/":
+            self._count_buf = ""
             self._visual_mode = ""
             self._mode = EditorMode.SEARCH
             self._search_buffer = ""
             self._search_forward = True
             self.status_msg = ""
         elif char == "?":
+            self._count_buf = ""
             self._visual_mode = ""
             self._mode = EditorMode.SEARCH
             self._search_buffer = ""
             self._search_forward = False
             self.status_msg = ""
         elif char == "n":
+            self._count_buf = ""
             self._goto_next_match()
         elif char == "N":
+            self._count_buf = ""
             self._goto_prev_match()
 
         # command mode
         elif char == ":":
+            self._count_buf = ""
             self._visual_mode = ""
             self._mode = EditorMode.COMMAND
             self.command_buffer = ""
@@ -273,45 +358,82 @@ class NormalMixin:
     def _handle_pending(self, char: str, key: str) -> None:
         if key == "escape" or not char:
             self.pending = ""
+            self._count_buf = ""
             self.status_msg = ""
             self._dot_stop()
             return
 
+        # pending 상태에서 숫자 입력 → count에 누적 (d3d 패턴)
+        if char.isdigit() and self.pending in ("d", "y", "c"):
+            self._count_buf += char
+            return
+
         combo = self.pending + char
         self.pending = ""
 
         if self.read_only and combo not in ("yy", "gg", "ej"):
+            self._count_buf = ""
             self.status_msg = "[readonly]"
             return
 
         if combo == "dd":
+            count = self._consume_count()
             self._save_undo()
             self._yank_type = "line"
-            self.yank_buffer = [self.lines[self.cursor_row]]
-            if len(self.lines) > 1:
-                deleted_at = self.cursor_row
-                self.lines.pop(self.cursor_row)
-                self._adjust_line_indices(deleted_at, -1)
+            yanked: list[str] = []
+            for _ in range(count):
+                if len(self.lines) <= 1 and not yanked:
+                    yanked.append(self.lines[0])
+                    self.lines[0] = ""
+                    break
+                if self.cursor_row >= len(self.lines):
+                    break
+                # fold-aware: fold 헤더이면 전체 블록 삭제
+                fold_end = self._folds.get(self.cursor_row)
+                if fold_end is not None:
+                    block = self.lines[self.cursor_row : fold_end + 1]
+                    yanked.extend(block)
+                    del self._folds[self.cursor_row]
+                    self._folded_lines_dirty = True
+                    block_len = len(block)
+                    del self.lines[self.cursor_row : self.cursor_row + block_len]
+                    if not self.lines:
+                        self.lines = [""]
+                    self._adjust_line_indices(self.cursor_row, -block_len)
+                else:
+                    yanked.append(self.lines[self.cursor_row])
+                    if len(self.lines) > 1:
+                        deleted_at = self.cursor_row
+                        self.lines.pop(self.cursor_row)
+                        self._adjust_line_indices(deleted_at, -1)
+                    else:
+                        self.lines[0] = ""
+                        break
                 if self.cursor_row >= len(self.lines):
                     self.cursor_row = len(self.lines) - 1
-            else:
-                self.lines[0] = ""
+            self.yank_buffer = yanked
+            if self.cursor_row >= len(self.lines):
+                self.cursor_row = len(self.lines) - 1
             self.cursor_col = 0
-            self.status_msg = "line deleted"
+            n = len(yanked)
+            self.status_msg = f"{n} line{'s' if n > 1 else ''} deleted"
             self._dot_stop()
 
         elif combo == "dw":
+            self._count_buf = ""
             self._save_undo()
             self._delete_word()
             self._dot_stop()
 
         elif combo == "d$":
+            self._count_buf = ""
             self._save_undo()
             line = self.lines[self.cursor_row]
             self.lines[self.cursor_row] = line[: self.cursor_col]
             self._dot_stop()
 
         elif combo == "d0":
+            self._count_buf = ""
             self._save_undo()
             line = self.lines[self.cursor_row]
             self.lines[self.cursor_row] = line[self.cursor_col :]
@@ -319,12 +441,14 @@ class NormalMixin:
             self._dot_stop()
 
         elif combo == "cw":
+            self._count_buf = ""
             self._save_undo()
             self._delete_word()
             self._enter_insert()
             # recording continues into insert mode
 
         elif combo == "cc":
+            self._count_buf = ""
             self._save_undo()
             self._yank_type = "line"
             indent = self._current_indent()
@@ -335,16 +459,36 @@ class NormalMixin:
             # recording continues into insert mode
 
         elif combo == "yy":
+            count = self._consume_count()
             self._yank_type = "line"
-            self.yank_buffer = [self.lines[self.cursor_row]]
-            self.status_msg = "line yanked"
+            yanked = []
+            row = self.cursor_row
+            for _ in range(count):
+                if row >= len(self.lines):
+                    break
+                # fold-aware: fold 헤더이면 전체 블록 yank
+                fold_end = self._folds.get(row)
+                if fold_end is not None:
+                    yanked.extend(self.lines[row : fold_end + 1])
+                    row = fold_end + 1
+                else:
+                    yanked.append(self.lines[row])
+                    row += 1
+            self.yank_buffer = yanked
+            n = len(yanked)
+            self.status_msg = f"{n} line{'s' if n > 1 else ''} yanked"
 
         elif combo == "gg":
-            self.cursor_row = 0
+            count = self._consume_count()
+            if count > 1:
+                self.cursor_row = count - 1
+            else:
+                self.cursor_row = 0
             self.cursor_col = 0
             self._scroll_cursor_to_top()
 
         elif len(combo) == 2 and combo[0] == "r":
+            self._count_buf = ""
             self._save_undo()
             line = self.lines[self.cursor_row]
             if self.cursor_col < len(line):
@@ -354,20 +498,27 @@ class NormalMixin:
             self._dot_stop()
 
         elif combo == "ej":
+            self._count_buf = ""
             self._edit_embedded_json()
 
         # fold 명령어
         elif combo == "za":
+            self._count_buf = ""
             self._toggle_fold(self.cursor_row)
         elif combo == "zo":
+            self._count_buf = ""
             self._open_fold(self.cursor_row)
         elif combo == "zc":
+            self._count_buf = ""
             self._close_fold(self.cursor_row)
         elif combo == "zM":
+            self._count_buf = ""
             self._fold_all()
         elif combo == "zR":
+            self._count_buf = ""
             self._unfold_all()
 
         else:
+            self._count_buf = ""
             self._dot_stop()
             self.status_msg = f"unknown: {combo}"