easymd-cli 0.1.0__tar.gz

easymd_cli-0.1.0/.gitignore

@@ -0,0 +1,4 @@
+__pycache__/
+*.pyc
+.venv/
+.uv/

easymd_cli-0.1.0/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Yiqi Yang (decajoin)
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

easymd_cli-0.1.0/PKG-INFO

@@ -0,0 +1,92 @@
+Metadata-Version: 2.4
+Name: easymd-cli
+Version: 0.1.0
+Summary: Terminal Markdown editor with vim-style keys and live side-by-side preview
+Project-URL: Repository, https://github.com/decajoin/easymd
+Project-URL: Issues, https://github.com/decajoin/easymd/issues
+Author-email: Yiqi Yang <yangyiqi5261@gmail.com>
+License-Expression: MIT
+License-File: LICENSE
+Keywords: editor,markdown,terminal,textual,tui,vim
+Classifier: Development Status :: 4 - Beta
+Classifier: Environment :: Console
+Classifier: Intended Audience :: Developers
+Classifier: Operating System :: OS Independent
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Topic :: Text Editors
+Classifier: Topic :: Text Processing :: Markup :: Markdown
+Requires-Python: >=3.11
+Requires-Dist: textual[syntax]>=8.0
+Description-Content-Type: text/markdown
+
+# easymd
+
+终端里的 Markdown 编辑器：左侧 vim 式编辑，右侧实时预览。基于 [Textual](https://textual.textualize.io/)。
+
+## 安装
+
+需要 Python 3.11+。
+
+使用 [uv](https://docs.astral.sh/uv/)（推荐）：
+
+```bash
+uv sync
+uv run easymd demo.md
+```
+
+或使用 pip：
+
+```bash
+pip install -r requirements.txt
+pip install -e .
+easymd demo.md        # 文件不存在时会在首次 :w 时创建
+```
+
+## 按键参考
+
+### 模式
+
+| 按键 | 作用 |
+| --- | --- |
+| `i` `a` `A` `I` `o` `O` | 进入插入模式（位置同 vim） |
+| `Esc` | 回到普通模式 |
+| `v` | 可视模式（`y`/`d`/`c` 作用于选区） |
+| `V` | 可视行模式（按整行选择，`y`/`d`/`c` 作用于整行；`v`/`V` 互切） |
+
+### 移动（普通/可视模式，支持数字前缀如 `3j`）
+
+`h j k l`、`w b e`、`0 ^ $`、`gg G`（`3G` 跳第 3 行）、`Ctrl+d/u` 半页、`Ctrl+f/b` 整页
+
+### 编辑
+
+| 按键 | 作用 |
+| --- | --- |
+| `x` | 删除光标处字符 |
+| `dd` / `yy` / `cc` | 删除 / 复制 / 改写整行（支持 `3dd`） |
+| `dw` `de` `d$` 等 | 操作符 + 移动（`y`、`c` 同理） |
+| `p` / `P` | 在后 / 前粘贴 |
+| `u` / `Ctrl+r` | 撤销 / 重做 |
+
+### 命令与搜索
+
+| 命令 | 作用 |
+| --- | --- |
+| `:w` `:w 文件名` | 保存 |
+| `:q` `:q!` `:wq` `:x` | 退出（有未保存修改时 `:q` 会拒绝） |
+| `/文本` 然后 `n` / `N` | 搜索 / 下一个 / 上一个 |
+
+## 项目结构
+
+```
+src/easymd/
+  cli.py     # 命令行入口
+  app.py     # 分屏布局、状态栏、命令行、预览同步
+  editor.py  # vim 模态层（TextArea 子类）
+tests/
+  smoke_test.py  # 无头冒烟测试（Textual Pilot 驱动按键）
+```
+
+运行测试：`uv run python tests/smoke_test.py`

easymd_cli-0.1.0/README.md

@@ -0,0 +1,68 @@
+# easymd
+
+终端里的 Markdown 编辑器：左侧 vim 式编辑，右侧实时预览。基于 [Textual](https://textual.textualize.io/)。
+
+## 安装
+
+需要 Python 3.11+。
+
+使用 [uv](https://docs.astral.sh/uv/)（推荐）：
+
+```bash
+uv sync
+uv run easymd demo.md
+```
+
+或使用 pip：
+
+```bash
+pip install -r requirements.txt
+pip install -e .
+easymd demo.md        # 文件不存在时会在首次 :w 时创建
+```
+
+## 按键参考
+
+### 模式
+
+| 按键 | 作用 |
+| --- | --- |
+| `i` `a` `A` `I` `o` `O` | 进入插入模式（位置同 vim） |
+| `Esc` | 回到普通模式 |
+| `v` | 可视模式（`y`/`d`/`c` 作用于选区） |
+| `V` | 可视行模式（按整行选择，`y`/`d`/`c` 作用于整行；`v`/`V` 互切） |
+
+### 移动（普通/可视模式，支持数字前缀如 `3j`）
+
+`h j k l`、`w b e`、`0 ^ $`、`gg G`（`3G` 跳第 3 行）、`Ctrl+d/u` 半页、`Ctrl+f/b` 整页
+
+### 编辑
+
+| 按键 | 作用 |
+| --- | --- |
+| `x` | 删除光标处字符 |
+| `dd` / `yy` / `cc` | 删除 / 复制 / 改写整行（支持 `3dd`） |
+| `dw` `de` `d$` 等 | 操作符 + 移动（`y`、`c` 同理） |
+| `p` / `P` | 在后 / 前粘贴 |
+| `u` / `Ctrl+r` | 撤销 / 重做 |
+
+### 命令与搜索
+
+| 命令 | 作用 |
+| --- | --- |
+| `:w` `:w 文件名` | 保存 |
+| `:q` `:q!` `:wq` `:x` | 退出（有未保存修改时 `:q` 会拒绝） |
+| `/文本` 然后 `n` / `N` | 搜索 / 下一个 / 上一个 |
+
+## 项目结构
+
+```
+src/easymd/
+  cli.py     # 命令行入口
+  app.py     # 分屏布局、状态栏、命令行、预览同步
+  editor.py  # vim 模态层（TextArea 子类）
+tests/
+  smoke_test.py  # 无头冒烟测试（Textual Pilot 驱动按键）
+```
+
+运行测试：`uv run python tests/smoke_test.py`

easymd_cli-0.1.0/demo.md

@@ -0,0 +1,28 @@
+# easymd 演示文档
+
+这是一个 **演示文件**，用来试用 easymd 的编辑和预览。
+
+## 功能列表
+
+- 左侧 vim 式编辑
+- 右侧实时 Markdown 预览
+- 光标移动时预览联动滚动
+
+## 代码块
+
+```python
+def hello(name: str) -> str:
+    return f"Hello, {name}!"
+```
+
+## 表格
+
+| 按键 | 作用 |
+| ---- | ---- |
+| `i`  | 进入插入模式 |
+| `dd` | 删除当前行 |
+| `:w` | 保存 |
+
+> 引用块也可以正常渲染。
+
+试着按 `i` 开始编辑，右边的预览会自动刷新。

easymd_cli-0.1.0/pyproject.toml

@@ -0,0 +1,40 @@
+[project]
+name = "easymd-cli"
+version = "0.1.0"
+description = "Terminal Markdown editor with vim-style keys and live side-by-side preview"
+readme = "README.md"
+license = "MIT"
+license-files = ["LICENSE"]
+requires-python = ">=3.11"
+authors = [{ name = "Yiqi Yang", email = "yangyiqi5261@gmail.com" }]
+keywords = ["markdown", "vim", "tui", "editor", "terminal", "textual"]
+classifiers = [
+    "Development Status :: 4 - Beta",
+    "Environment :: Console",
+    "Intended Audience :: Developers",
+    "Operating System :: OS Independent",
+    "Programming Language :: Python :: 3",
+    "Programming Language :: Python :: 3.11",
+    "Programming Language :: Python :: 3.12",
+    "Programming Language :: Python :: 3.13",
+    "Topic :: Text Editors",
+    "Topic :: Text Processing :: Markup :: Markdown",
+]
+dependencies = ["textual[syntax]>=8.0"]
+
+[project.scripts]
+easymd = "easymd.cli:main"
+
+[project.urls]
+Repository = "https://github.com/decajoin/easymd"
+Issues = "https://github.com/decajoin/easymd/issues"
+
+[build-system]
+requires = ["hatchling>=1.27"]
+build-backend = "hatchling.build"
+
+[tool.hatch.build.targets.wheel]
+packages = ["src/easymd"]
+
+[tool.hatch.build.targets.sdist]
+include = ["src", "tests", "demo.md", "README.md", "LICENSE"]

easymd_cli-0.1.0/src/easymd/__init__.py

@@ -0,0 +1,3 @@
+"""easymd: terminal Markdown editor with vim keys and live preview."""
+
+__version__ = "0.1.0"

easymd_cli-0.1.0/src/easymd/__main__.py

@@ -0,0 +1,3 @@
+from .cli import main
+
+main()

easymd_cli-0.1.0/src/easymd/app.py

@@ -0,0 +1,214 @@
+"""The easymd application: editor pane, live Markdown preview, vim command line."""
+
+from __future__ import annotations
+
+from pathlib import Path
+
+from rich.markup import escape
+from textual import events
+from textual.app import App, ComposeResult
+from textual.containers import Horizontal, VerticalScroll
+from textual.message import Message
+from textual.widgets import Input, Markdown, Static, TextArea
+
+from .editor import VimTextArea
+
+MODE_STYLES = {
+    "normal": ("NORMAL", "blue"),
+    "insert": ("INSERT", "green"),
+    "visual": ("VISUAL", "magenta"),
+    "visual_line": ("V-LINE", "magenta"),
+}
+
+
+class CommandLine(Input):
+    """The `:` / `/` command line; escape cancels back to the editor."""
+
+    class Cancelled(Message):
+        pass
+
+    def __init__(self, **kwargs) -> None:
+        # Focus must not select the prefix, or the first keystroke replaces it.
+        kwargs.setdefault("select_on_focus", False)
+        super().__init__(**kwargs)
+
+    async def _on_key(self, event: events.Key) -> None:
+        if event.key == "escape":
+            event.stop()
+            event.prevent_default()
+            self.post_message(self.Cancelled())
+            return
+        await super()._on_key(event)
+
+
+class EasyMDApp(App):
+    TITLE = "easymd"
+
+    CSS = """
+    #main { height: 1fr; }
+    #editor { width: 1fr; border: none; }
+    #preview-scroll {
+        width: 1fr;
+        border-left: heavy $accent;
+        padding: 0 1;
+        scrollbar-size-vertical: 1;
+    }
+    #status { dock: bottom; height: 1; background: $panel; padding: 0 1; }
+    #cmdline {
+        dock: bottom;
+        height: 1;
+        border: none;
+        padding: 0 1;
+        background: $surface;
+        display: none;
+    }
+    """
+
+    def __init__(self, path: Path) -> None:
+        super().__init__()
+        self.path = path
+        self._saved_text = (
+            path.read_text(encoding="utf-8") if path.exists() else ""
+        )
+        self._preview_timer = None
+        self._notice = ""
+
+    # ------------------------------------------------------------------
+    # Layout
+
+    def compose(self) -> ComposeResult:
+        editor = VimTextArea(self._saved_text, id="editor", show_line_numbers=True)
+        try:
+            editor.language = "markdown"
+        except Exception:
+            pass  # syntax highlighting is optional (needs textual[syntax])
+        with Horizontal(id="main"):
+            yield editor
+            with VerticalScroll(id="preview-scroll"):
+                yield Markdown(self._saved_text, id="preview")
+        yield Static(id="status")
+        yield CommandLine(id="cmdline")
+
+    def on_mount(self) -> None:
+        self.editor.focus()
+        self._update_status()
+
+    @property
+    def editor(self) -> VimTextArea:
+        return self.query_one("#editor", VimTextArea)
+
+    @property
+    def modified(self) -> bool:
+        return self.editor.text != self._saved_text
+
+    # ------------------------------------------------------------------
+    # Status bar
+
+    def _update_status(self) -> None:
+        try:
+            status = self.query_one("#status", Static)
+        except Exception:
+            return
+        ed = self.editor
+        label, color = MODE_STYLES[ed.mode]
+        row, col = ed.cursor_location
+        flag = " ●" if self.modified else ""
+        notice = f"  {escape(self._notice)}" if self._notice else ""
+        status.update(
+            f"[bold white on {color}] {label} [/] "
+            f"{escape(self.path.name)}{flag}{notice}"
+            f"[dim]  {row + 1}:{col + 1}[/]"
+        )
+
+    # ------------------------------------------------------------------
+    # Editor events
+
+    def on_text_area_changed(self, event: TextArea.Changed) -> None:
+        if self._preview_timer is not None:
+            self._preview_timer.stop()
+        self._preview_timer = self.set_timer(0.25, self._refresh_preview)
+        self._update_status()
+
+    def on_text_area_selection_changed(
+        self, event: TextArea.SelectionChanged
+    ) -> None:
+        self._update_status()
+        self._sync_scroll()
+
+    def on_vim_text_area_mode_changed(
+        self, event: VimTextArea.ModeChanged
+    ) -> None:
+        self._notice = ""
+        self._update_status()
+
+    async def _refresh_preview(self) -> None:
+        await self.query_one("#preview", Markdown).update(self.editor.text)
+        self._sync_scroll()
+
+    def _sync_scroll(self) -> None:
+        try:
+            scroller = self.query_one("#preview-scroll", VerticalScroll)
+        except Exception:
+            return
+        ed = self.editor
+        total = max(1, ed.document.line_count - 1)
+        fraction = ed.cursor_location[0] / total
+        scroller.scroll_to(y=fraction * scroller.max_scroll_y, animate=False)
+
+    # ------------------------------------------------------------------
+    # Command line (: and /)
+
+    def on_vim_text_area_command_requested(
+        self, event: VimTextArea.CommandRequested
+    ) -> None:
+        cmdline = self.query_one("#cmdline", CommandLine)
+        cmdline.display = True
+        cmdline.value = event.prefix
+        cmdline.cursor_position = len(cmdline.value)
+        cmdline.focus()
+
+    def _hide_cmdline(self) -> None:
+        cmdline = self.query_one("#cmdline", CommandLine)
+        cmdline.value = ""
+        cmdline.display = False
+        self.editor.focus()
+
+    def on_command_line_cancelled(self, event: CommandLine.Cancelled) -> None:
+        self._hide_cmdline()
+
+    def on_input_submitted(self, event: Input.Submitted) -> None:
+        value = event.value
+        self._hide_cmdline()
+        if value.startswith("/"):
+            pattern = value[1:]
+            if pattern:
+                self.editor.set_search(pattern)
+        elif value.startswith(":"):
+            self._run_command(value[1:].strip())
+
+    def _run_command(self, command: str) -> None:
+        parts = command.split()
+        if not parts:
+            return
+        name, args = parts[0], parts[1:]
+        if name in ("w", "w!", "wq", "x"):
+            target = Path(args[0]) if args else self.path
+            try:
+                target.write_text(self.editor.text, encoding="utf-8")
+            except OSError as error:
+                self._notice = f"E212: Can't open file for writing: {error}"
+                self._update_status()
+                return
+            if target == self.path:
+                self._saved_text = self.editor.text
+            self._notice = f'"{target}" written'
+            if name in ("wq", "x"):
+                self.exit()
+        elif name in ("q", "q!", "qa", "qa!"):
+            if name.endswith("!") or not self.modified:
+                self.exit()
+            else:
+                self._notice = "E37: No write since last change (add ! to override)"
+        else:
+            self._notice = f"E492: Not an editor command: {name}"
+        self._update_status()

easymd_cli-0.1.0/src/easymd/cli.py

@@ -0,0 +1,29 @@
+"""Command-line entry point for easymd."""
+
+from __future__ import annotations
+
+import argparse
+from pathlib import Path
+
+from . import __version__
+from .app import EasyMDApp
+
+
+def main() -> None:
+    parser = argparse.ArgumentParser(
+        prog="easymd",
+        description="Terminal Markdown editor with vim keys and live preview.",
+    )
+    parser.add_argument(
+        "file",
+        help="Markdown file to edit (created on first :w if it does not exist)",
+    )
+    parser.add_argument(
+        "--version", action="version", version=f"%(prog)s {__version__}"
+    )
+    args = parser.parse_args()
+    EasyMDApp(Path(args.file)).run()
+
+
+if __name__ == "__main__":
+    main()

easymd_cli-0.1.0/src/easymd/editor.py

@@ -0,0 +1,459 @@
+"""Vim-style modal editing layer on top of Textual's TextArea."""
+
+from __future__ import annotations
+
+import re
+
+from textual import events
+from textual.message import Message
+from textual.widgets import TextArea
+from textual.widgets.text_area import Selection
+
+# A vim "word": a run of word chars, or a run of punctuation.
+WORD_RE = re.compile(r"\w+|[^\w\s]+")
+
+NORMAL = "normal"
+INSERT = "insert"
+VISUAL = "visual"
+VISUAL_LINE = "visual_line"
+
+
+class VimTextArea(TextArea):
+    """TextArea with a vim-like modal key layer (normal / insert / visual)."""
+
+    class ModeChanged(Message):
+        def __init__(self, mode: str) -> None:
+            super().__init__()
+            self.mode = mode
+
+    class CommandRequested(Message):
+        """User pressed `:` or `/` in normal mode; the app owns the command line."""
+
+        def __init__(self, prefix: str) -> None:
+            super().__init__()
+            self.prefix = prefix
+
+    def __init__(self, text: str = "", **kwargs) -> None:
+        kwargs.setdefault("tab_behavior", "indent")
+        super().__init__(text, **kwargs)
+        self.mode = NORMAL
+        self._count = ""
+        self._pending = ""  # pending operator/prefix: d, y, c or g
+        self._register: tuple[str, bool] = ("", False)  # (text, linewise)
+        self._search = ""
+        self._line_anchor = 0  # anchor row for visual line mode
+
+    # ------------------------------------------------------------------
+    # Modes
+
+    def _set_mode(self, mode: str) -> None:
+        if mode == self.mode:
+            return
+        self.mode = mode
+        self._count = ""
+        self._pending = ""
+        self.post_message(self.ModeChanged(mode))
+
+    # ------------------------------------------------------------------
+    # Key dispatch
+
+    async def _on_key(self, event: events.Key) -> None:
+        if self.mode == INSERT:
+            if event.key == "escape":
+                event.stop()
+                event.prevent_default()
+                row, col = self.cursor_location
+                if col > 0:
+                    self.move_cursor((row, col - 1))
+                self._set_mode(NORMAL)
+                return
+            await super()._on_key(event)
+            return
+        # Normal / visual mode: nothing reaches the underlying TextArea.
+        event.stop()
+        event.prevent_default()
+        self._handle_modal_key(event)
+
+    def _handle_modal_key(self, event: events.Key) -> None:
+        key = event.key
+        char = event.character if event.is_printable else None
+
+        if key == "escape":
+            if self.mode in (VISUAL, VISUAL_LINE):
+                self.selection = Selection.cursor(self.cursor_location)
+            self._set_mode(NORMAL)
+            self._count = ""
+            self._pending = ""
+            return
+
+        # Count prefix; a lone 0 is the line-start motion, not a count.
+        if char and char.isdigit() and not (char == "0" and not self._count):
+            self._count += char
+            return
+
+        n = int(self._count) if self._count else 1
+        explicit_count = bool(self._count)
+        self._count = ""
+        pending, self._pending = self._pending, ""
+
+        if pending == "g":
+            if char == "g":
+                last = self.document.line_count - 1
+                row = min(n - 1, last) if explicit_count else 0
+                self._move((row, 0))
+            return
+
+        if pending in ("d", "y", "c"):
+            self._handle_operator(pending, char, key, n, explicit_count)
+            return
+
+        # Visual-mode operators act on the selection.
+        if char in ("d", "x", "y", "c"):
+            if self.mode == VISUAL:
+                self._visual_operate(char)
+                return
+            if self.mode == VISUAL_LINE:
+                self._visual_line_operate(char)
+                return
+
+        # Plain motions (extend the selection in visual mode).
+        target = self._motion_target(char or key, n, explicit_count)
+        if target is not None:
+            self._move(target)
+            return
+
+        self._handle_command_key(char, key, n, explicit_count)
+
+    def _move(self, target: tuple[int, int]) -> None:
+        if self.mode == VISUAL_LINE:
+            self.move_cursor(target)
+            self._update_linewise_selection()
+        else:
+            self.move_cursor(target, select=self.mode == VISUAL)
+
+    def _update_linewise_selection(self) -> None:
+        """Expand the selection to whole lines between the anchor and the cursor."""
+        row = self.cursor_location[0]
+        anchor = self._line_anchor
+        doc = self.document
+        if row >= anchor:
+            self.selection = Selection(
+                (anchor, 0), (row, len(doc.get_line(row)))
+            )
+        else:
+            self.selection = Selection(
+                (anchor, len(doc.get_line(anchor))), (row, 0)
+            )
+
+    # ------------------------------------------------------------------
+    # Normal-mode commands
+
+    def _handle_command_key(
+        self, char: str | None, key: str, n: int, explicit_count: bool
+    ) -> None:
+        doc = self.document
+        row, col = self.cursor_location
+
+        if char == "i":
+            self._set_mode(INSERT)
+        elif char == "a":
+            line = doc.get_line(row)
+            if col < len(line):
+                self.move_cursor((row, col + 1))
+            self._set_mode(INSERT)
+        elif char == "A":
+            self.move_cursor((row, len(doc.get_line(row))))
+            self._set_mode(INSERT)
+        elif char == "I":
+            line = doc.get_line(row)
+            self.move_cursor((row, len(line) - len(line.lstrip())))
+            self._set_mode(INSERT)
+        elif char == "o":
+            self.move_cursor((row, len(doc.get_line(row))))
+            self.insert("\n")
+            self._set_mode(INSERT)
+        elif char == "O":
+            self.move_cursor((row, 0))
+            self.insert("\n")
+            self.move_cursor((row, 0))
+            self._set_mode(INSERT)
+        elif char == "x":
+            line = doc.get_line(row)
+            end = min(len(line), col + n)
+            if end > col:
+                self._register = (self.get_text_range((row, col), (row, end)), False)
+                self.delete((row, col), (row, end))
+        elif char in ("d", "y", "c"):
+            self._pending = char
+            if explicit_count:
+                self._count = str(n)
+        elif char == "g":
+            self._pending = "g"
+            if explicit_count:
+                self._count = str(n)
+        elif char == "v":
+            if self.mode == VISUAL:
+                self.selection = Selection.cursor(self.cursor_location)
+                self._set_mode(NORMAL)
+            else:
+                # From normal or visual line; keep the selection when switching.
+                self._set_mode(VISUAL)
+        elif char == "V":
+            if self.mode == VISUAL_LINE:
+                self.selection = Selection.cursor(self.cursor_location)
+                self._set_mode(NORMAL)
+            else:
+                # Anchor on the selection start when coming from charwise visual.
+                if self.mode == VISUAL:
+                    self._line_anchor = min(
+                        self.selection.start[0], self.selection.end[0]
+                    )
+                else:
+                    self._line_anchor = row
+                self._set_mode(VISUAL_LINE)
+                self._update_linewise_selection()
+        elif char == "p":
+            self._paste(after=True, n=n)
+        elif char == "P":
+            self._paste(after=False, n=n)
+        elif char == "u":
+            self.undo()
+        elif key == "ctrl+r":
+            self.redo()
+        elif char in (":", "/"):
+            self.post_message(self.CommandRequested(char))
+        elif char == "n":
+            self.search_next()
+        elif char == "N":
+            self.search_next(reverse=True)
+        elif key in ("ctrl+d", "ctrl+u"):
+            half = max(1, self.size.height // 2)
+            delta = half if key == "ctrl+d" else -half
+            new_row = max(0, min(doc.line_count - 1, row + delta))
+            self._move((new_row, min(col, len(doc.get_line(new_row)))))
+        elif key in ("ctrl+f", "pagedown"):
+            self.action_cursor_page_down()
+        elif key in ("ctrl+b", "pageup"):
+            self.action_cursor_page_up()
+
+    # ------------------------------------------------------------------
+    # Motions
+
+    def _motion_target(
+        self, sym: str, n: int, explicit_count: bool
+    ) -> tuple[int, int] | None:
+        doc = self.document
+        row, col = self.cursor_location
+        last = doc.line_count - 1
+
+        def clamp(r: int, c: int) -> tuple[int, int]:
+            return (r, min(c, len(doc.get_line(r))))
+
+        if sym in ("h", "left"):
+            return (row, max(0, col - n))
+        if sym in ("l", "right"):
+            return clamp(row, col + n)
+        if sym in ("j", "down"):
+            return clamp(min(last, row + n), col)
+        if sym in ("k", "up"):
+            return clamp(max(0, row - n), col)
+        if sym in ("0", "home"):
+            return (row, 0)
+        if sym == "^":
+            line = doc.get_line(row)
+            return (row, len(line) - len(line.lstrip()))
+        if sym in ("$", "end"):
+            return (row, len(doc.get_line(row)))
+        if sym == "G":
+            return (min(n - 1, last) if explicit_count else last, 0)
+        if sym == "w":
+            return self._next_word(n, end=False)
+        if sym == "e":
+            return self._next_word(n, end=True)
+        if sym == "b":
+            return self._prev_word(n)
+        return None
+
+    def _next_word(self, n: int, end: bool) -> tuple[int, int]:
+        row, col = self.cursor_location
+        for _ in range(n):
+            row, col = self._scan_forward(row, col, end)
+        return (row, col)
+
+    def _scan_forward(self, row: int, col: int, end: bool) -> tuple[int, int]:
+        doc = self.document
+        for r in range(row, doc.line_count):
+            for m in WORD_RE.finditer(doc.get_line(r)):
+                pos = m.start() if not end else m.end() - 1
+                if r > row or pos > col:
+                    return (r, pos)
+        last = doc.line_count - 1
+        return (last, max(0, len(doc.get_line(last)) - (1 if end else 0)))
+
+    def _prev_word(self, n: int) -> tuple[int, int]:
+        row, col = self.cursor_location
+        for _ in range(n):
+            row, col = self._scan_back(row, col)
+        return (row, col)
+
+    def _scan_back(self, row: int, col: int) -> tuple[int, int]:
+        doc = self.document
+        for r in range(row, -1, -1):
+            best = None
+            for m in WORD_RE.finditer(doc.get_line(r)):
+                if r < row or m.start() < col:
+                    best = m.start()
+                else:
+                    break
+            if best is not None:
+                return (r, best)
+        return (0, 0)
+
+    # ------------------------------------------------------------------
+    # Operators (d / y / c)
+
+    def _line_range_text(self, row: int, end_row: int) -> str:
+        end_col = len(self.document.get_line(end_row))
+        return self.get_text_range((row, 0), (end_row, end_col))
+
+    def _delete_lines(self, n: int) -> None:
+        doc = self.document
+        row, _ = self.cursor_location
+        last = doc.line_count - 1
+        end_row = min(row + n - 1, last)
+        self._register = (self._line_range_text(row, end_row) + "\n", True)
+        if end_row < last:
+            self.delete((row, 0), (end_row + 1, 0))
+        elif row > 0:
+            # Deleting through the last line: eat the preceding newline instead.
+            self.delete(
+                (row - 1, len(doc.get_line(row - 1))),
+                (end_row, len(doc.get_line(end_row))),
+            )
+        else:
+            self.delete((0, 0), (end_row, len(doc.get_line(end_row))))
+        new_last = self.document.line_count - 1
+        self.move_cursor((min(row, new_last), 0))
+
+    def _handle_operator(
+        self, op: str, char: str | None, key: str, n: int, explicit_count: bool
+    ) -> None:
+        # Doubled operator (dd / yy / cc) works on whole lines.
+        if char == op:
+            row, _ = self.cursor_location
+            end_row = min(row + n - 1, self.document.line_count - 1)
+            if op == "y":
+                self._register = (self._line_range_text(row, end_row) + "\n", True)
+            elif op == "d":
+                self._delete_lines(n)
+            else:  # cc: clear the lines' content and start inserting
+                self._register = (self._line_range_text(row, end_row) + "\n", True)
+                end_col = len(self.document.get_line(end_row))
+                self.delete((row, 0), (end_row, end_col))
+                self.move_cursor((row, 0))
+                self._set_mode(INSERT)
+            return
+
+        target = self._motion_target(char or key, n, explicit_count)
+        if target is None:
+            return
+        start = self.cursor_location
+        if target < start:
+            start, target = target, start
+        elif char == "e":
+            # 'e' is an inclusive motion: take the character under the target too.
+            target = (target[0], target[1] + 1)
+        text = self.get_text_range(start, target)
+        if not text:
+            return
+        self._register = (text, False)
+        if op == "y":
+            self.move_cursor(start)
+            return
+        self.delete(start, target)
+        if op == "c":
+            self._set_mode(INSERT)
+
+    def _visual_line_operate(self, char: str) -> None:
+        sel = self.selection
+        row, end_row = sorted([sel.start[0], sel.end[0]])
+        self._register = (self._line_range_text(row, end_row) + "\n", True)
+        if char == "y":
+            self.move_cursor((row, 0))
+        elif char == "c":
+            end_col = len(self.document.get_line(end_row))
+            self.delete((row, 0), (end_row, end_col))
+            self.move_cursor((row, 0))
+        else:  # d / x: remove the lines entirely, dd-style
+            self.move_cursor((row, 0))
+            self._delete_lines(end_row - row + 1)
+        self._set_mode(INSERT if char == "c" else NORMAL)
+
+    def _visual_operate(self, char: str) -> None:
+        sel = self.selection
+        start, end = sorted([sel.start, sel.end])
+        # Vim's visual selection includes the character under the cursor.
+        line_len = len(self.document.get_line(end[0]))
+        end = (end[0], min(line_len, end[1] + 1))
+        text = self.get_text_range(start, end)
+        self._register = (text, False)
+        if char == "y":
+            self.move_cursor(start)
+        else:  # d / x / c
+            self.delete(start, end)
+        self._set_mode(INSERT if char == "c" else NORMAL)
+
+    # ------------------------------------------------------------------
+    # Paste
+
+    def _paste(self, after: bool, n: int = 1) -> None:
+        text, linewise = self._register
+        if not text:
+            return
+        text = text * n
+        doc = self.document
+        row, col = self.cursor_location
+        if linewise:
+            if after:
+                if row == doc.line_count - 1:
+                    eol = (row, len(doc.get_line(row)))
+                    self.insert("\n" + text.rstrip("\n"), eol)
+                else:
+                    self.insert(text, (row + 1, 0))
+                self.move_cursor((row + 1, 0))
+            else:
+                self.insert(text, (row, 0))
+                self.move_cursor((row, 0))
+        else:
+            line = doc.get_line(row)
+            loc = (row, min(col + 1, len(line))) if after and line else (row, col)
+            self.insert(text, loc, maintain_selection_offset=False)
+
+    # ------------------------------------------------------------------
+    # Search
+
+    def set_search(self, pattern: str) -> None:
+        self._search = pattern
+        self.search_next()
+
+    def search_next(self, reverse: bool = False) -> None:
+        if not self._search:
+            return
+        doc = self.document
+        matches: list[tuple[int, int]] = []
+        for r in range(doc.line_count):
+            line = doc.get_line(r)
+            i = line.find(self._search)
+            while i >= 0:
+                matches.append((r, i))
+                i = line.find(self._search, i + 1)
+        if not matches:
+            return
+        here = self.cursor_location
+        if reverse:
+            before = [m for m in matches if m < here]
+            target = before[-1] if before else matches[-1]
+        else:
+            after = [m for m in matches if m > here]
+            target = after[0] if after else matches[0]
+        self.move_cursor(target)

easymd_cli-0.1.0/tests/smoke_test.py

@@ -0,0 +1,133 @@
+"""Headless smoke test: drives the app with Textual's Pilot and asserts vim behavior."""
+
+import asyncio
+import tempfile
+from pathlib import Path
+
+from easymd.app import EasyMDApp
+
+SAMPLE = "# Title\n\nhello world\nsecond line\n"
+
+
+async def run() -> None:
+    tmp = Path(tempfile.mkdtemp()) / "t.md"
+    tmp.write_text(SAMPLE, encoding="utf-8")
+    app = EasyMDApp(tmp)
+    async with app.run_test(size=(120, 40)) as pilot:
+        ed = app.editor
+        assert ed.mode == "normal", ed.mode
+
+        # Motions: j, gg, G, counts
+        await pilot.press("j")
+        assert ed.cursor_location[0] == 1
+        await pilot.press("G")
+        assert ed.cursor_location[0] == ed.document.line_count - 1
+        await pilot.press("g", "g")
+        assert ed.cursor_location == (0, 0)
+        await pilot.press("3", "G")
+        assert ed.cursor_location[0] == 2
+
+        # Word motions on "hello world"
+        await pilot.press("w")
+        assert ed.cursor_location == (2, 6), ed.cursor_location
+        await pilot.press("b")
+        assert ed.cursor_location == (2, 0)
+        await pilot.press("e")
+        assert ed.cursor_location == (2, 4)
+        await pilot.press("dollar_sign")
+        assert ed.cursor_location == (2, len("hello world"))
+
+        # Insert mode
+        await pilot.press("g", "g", "i")
+        assert ed.mode == "insert"
+        await pilot.press("X", "Y")
+        await pilot.press("escape")
+        assert ed.mode == "normal"
+        assert ed.text.startswith("XY# Title"), ed.text[:20]
+        assert app.modified
+
+        # dd deletes the first line, p pastes it back below
+        await pilot.press("g", "g", "d", "d")
+        assert ed.text.startswith("\nhello"), ed.text[:12]
+        await pilot.press("p")
+        assert ed.document.get_line(1) == "XY# Title", ed.document.get_line(1)
+
+        # yy / p duplicates a line
+        before = ed.document.line_count
+        await pilot.press("y", "y", "p")
+        assert ed.document.line_count == before + 1
+
+        # x deletes a character
+        await pilot.press("g", "g", "j", "0", "x")
+        assert ed.document.get_line(1) == "Y# Title", ed.document.get_line(1)
+
+        # Search via /
+        await pilot.press("slash")
+        for ch in "world":
+            await pilot.press(ch)
+        await pilot.press("enter")
+        row, col = ed.cursor_location
+        assert ed.document.get_line(row)[col : col + 5] == "world"
+
+        # Visual line mode: V selects the whole line, j extends, y yanks linewise
+        await pilot.press("g", "g", "j")  # on "Y# Title"
+        await pilot.press("V")
+        assert ed.mode == "visual_line"
+        start, end = sorted([ed.selection.start, ed.selection.end])
+        assert start == (1, 0) and end == (1, len("Y# Title")), ed.selection
+        await pilot.press("j")
+        start, end = sorted([ed.selection.start, ed.selection.end])
+        assert start[0] == 1 and end[0] == 2, ed.selection
+        await pilot.press("y")
+        assert ed.mode == "normal"
+        assert ed._register == ("Y# Title\nXY# Title\n", True), ed._register
+
+        # V + p: paste the two yanked lines below
+        lines_before = ed.document.line_count
+        await pilot.press("p")
+        assert ed.document.line_count == lines_before + 2
+
+        # V + d removes exactly the selected lines
+        await pilot.press("g", "g", "V", "j", "d")
+        assert ed.mode == "normal"
+        assert ed.document.line_count == lines_before
+        assert ed._register[1] is True  # linewise register
+
+        # V then k extends upward; escape collapses back to normal
+        await pilot.press("j", "j", "V", "k")
+        start, end = sorted([ed.selection.start, ed.selection.end])
+        assert end[0] - start[0] == 1, ed.selection
+        await pilot.press("escape")
+        assert ed.mode == "normal"
+        assert ed.selection.start == ed.selection.end
+
+        # v <-> V switching keeps a sensible selection
+        await pilot.press("V", "v")
+        assert ed.mode == "visual"
+        await pilot.press("V")
+        assert ed.mode == "visual_line"
+        await pilot.press("escape")
+
+        # :w writes the file and clears the modified flag
+        await pilot.press("colon", "w", "enter")
+        await pilot.pause()
+        assert tmp.read_text(encoding="utf-8") == ed.text
+        assert not app.modified
+
+        # :q with changes refuses; :q! quits
+        await pilot.press("i", "z", "escape")
+        await pilot.press("colon", "q", "enter")
+        await pilot.pause()
+        assert "E37" in app._notice, app._notice
+
+        # Preview eventually picks up the edit
+        await pilot.pause(0.5)
+
+        await pilot.press("colon", "q", "exclamation_mark", "enter")
+        await pilot.pause()
+
+    print("smoke test passed")
+
+
+if __name__ == "__main__":
+    asyncio.run(run())