jim_editor 0.1.0__tar.gz

jim_editor-0.1.0/PKG-INFO

@@ -0,0 +1,22 @@
+Metadata-Version: 2.4
+Name: jim_editor
+Version: 0.1.0
+Summary: A fast, simple terminal text editor
+Requires-Python: >=3.14
+Requires-Dist: pyperclip>=1.9
+Requires-Dist: textual>=8.2
+Requires-Dist: tree-sitter>=0.23
+Requires-Dist: tree-sitter-python
+Requires-Dist: tree-sitter-javascript
+Requires-Dist: tree-sitter-yaml
+Requires-Dist: tree-sitter-html
+Requires-Dist: tree-sitter-go
+Requires-Dist: tree-sitter-rust
+Requires-Dist: tree-sitter-json
+Requires-Dist: tree-sitter-toml
+Requires-Dist: tree-sitter-bash
+Requires-Dist: tree-sitter-xml
+Requires-Dist: tree-sitter-css
+Requires-Dist: tree-sitter-java
+Requires-Dist: tree-sitter-markdown
+Requires-Dist: tree-sitter-sql

jim_editor-0.1.0/pyproject.toml

@@ -0,0 +1,55 @@
+[build-system]
+requires = ["setuptools>=69", "wheel"]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "jim_editor"
+version = "0.1.0"
+description = "A fast, simple terminal text editor"
+requires-python = ">=3.14"
+dependencies = [
+	"pyperclip>=1.9",
+	"textual>=8.2",
+	"tree-sitter>=0.23",
+	"tree-sitter-python",
+	"tree-sitter-javascript",
+	"tree-sitter-yaml",
+	"tree-sitter-html",
+	"tree-sitter-go",
+	"tree-sitter-rust",
+	"tree-sitter-json",
+	"tree-sitter-toml",
+	"tree-sitter-bash",
+	"tree-sitter-xml",
+	"tree-sitter-css",
+	"tree-sitter-java",
+	"tree-sitter-markdown",
+	"tree-sitter-sql",
+]
+
+[project.scripts]
+jim_editor = "jim_editor.__main__:main"
+
+[dependency-groups]
+dev = [
+	"mkdocs-material>=9",
+	"mike>=2",
+	"pytest>=8",
+	"ruff>=0.9",
+]
+
+[tool.setuptools]
+package-dir = {"" = "src"}
+
+[tool.setuptools.packages.find]
+where = ["src"]
+
+[tool.ruff]
+target-version = "py314"
+line-length = 100
+
+[tool.ruff.lint]
+select = ["E", "F", "I"]
+
+[tool.pytest.ini_options]
+testpaths = ["tests"]

jim_editor-0.1.0/setup.cfg

@@ -0,0 +1,4 @@
+[egg_info]
+tag_build = 
+tag_date = 0
+

jim_editor-0.1.0/src/jim_editor/__init__.py

@@ -0,0 +1,5 @@
+"""jim editor package."""
+
+__all__ = ["__version__"]
+
+__version__ = "0.1.0"

jim_editor-0.1.0/src/jim_editor/__main__.py

@@ -0,0 +1,4 @@
+from .app import main
+
+if __name__ == "__main__":
+    raise SystemExit(main())

jim_editor-0.1.0/src/jim_editor/app.py

@@ -0,0 +1,1057 @@
+from __future__ import annotations
+
+import argparse
+import os
+import re
+from dataclasses import dataclass
+from pathlib import Path
+from tempfile import NamedTemporaryFile
+
+import pyperclip
+from textual.app import App, ComposeResult
+from textual.binding import Binding
+from textual.containers import Horizontal, Vertical
+from textual.screen import ModalScreen
+from textual.widgets import (
+    Button,
+    Checkbox,
+    DirectoryTree,
+    Input,
+    Static,
+    TabbedContent,
+    TabPane,
+    TextArea,
+)
+
+
+@dataclass(frozen=True)
+class SearchRequest:
+    query: str
+    regex: bool
+
+
+@dataclass(frozen=True)
+class SearchMatch:
+    start: tuple[int, int]
+    end: tuple[int, int]
+
+
+SEARCH_HIGHLIGHT_NAME = "keyword"
+
+
+def detect_newline(text: str) -> str:
+    if "\r\n" in text:
+        return "\r\n"
+    if "\r" in text:
+        return "\r"
+    return "\n"
+
+
+def normalize_newlines(text: str) -> str:
+    return text.replace("\r\n", "\n").replace("\r", "\n")
+
+
+def end_location(text: str) -> tuple[int, int]:
+    lines = text.split("\n")
+    return len(lines) - 1, len(lines[-1])
+
+
+def location_to_offset(text: str, location: tuple[int, int]) -> int:
+    row, column = location
+    lines = text.split("\n")
+    row = max(0, min(row, len(lines) - 1))
+    column = max(0, column)
+    offset = 0
+    for line in lines[:row]:
+        offset += len(line) + 1
+    return min(offset + min(column, len(lines[row])), len(text))
+
+
+def offset_to_location(text: str, offset: int) -> tuple[int, int]:
+    offset = max(0, min(offset, len(text)))
+    row = 0
+    column = 0
+    for character in text[:offset]:
+        if character == "\n":
+            row += 1
+            column = 0
+        else:
+            column += 1
+    return row, column
+
+
+def goto_line_location(text: str, line_number: int) -> tuple[int, int]:
+    if line_number <= 1:
+        return 0, 0
+    lines = text.split("\n")
+    if line_number > len(lines):
+        return end_location(text)
+    return line_number - 1, 0
+
+
+def search_document(
+    text: str,
+    query: str,
+    *,
+    regex: bool = False,
+    start_location: tuple[int, int] = (0, 0),
+) -> SearchMatch | None:
+    matches = find_search_matches(text, query, regex=regex)
+    if not matches:
+        return None
+    return find_next_search_match(text, matches, start_location)
+
+
+def find_search_matches(text: str, query: str, *, regex: bool = False) -> list[SearchMatch]:
+    if not query:
+        return []
+
+    matches: list[SearchMatch] = []
+    if regex:
+        pattern = re.compile(query, re.MULTILINE)
+        for match in pattern.finditer(text):
+            if match.start() == match.end():
+                continue
+            matches.append(
+                SearchMatch(
+                    start=offset_to_location(text, match.start()),
+                    end=offset_to_location(text, match.end()),
+                ),
+            )
+    else:
+        query_length = len(query)
+        search_start = 0
+        while True:
+            match_start = text.find(query, search_start)
+            if match_start == -1:
+                break
+            matches.append(
+                SearchMatch(
+                    start=offset_to_location(text, match_start),
+                    end=offset_to_location(text, match_start + query_length),
+                ),
+            )
+            search_start = match_start + max(query_length, 1)
+
+    return matches
+
+
+def find_next_search_match(
+    text: str,
+    matches: list[SearchMatch],
+    start_location: tuple[int, int],
+) -> SearchMatch | None:
+    if not matches:
+        return None
+
+    start_offset = location_to_offset(text, start_location)
+    for match in matches:
+        if location_to_offset(text, match.start) >= start_offset:
+            return match
+    return matches[0]
+
+
+def find_previous_search_match(
+    text: str,
+    matches: list[SearchMatch],
+    start_location: tuple[int, int],
+) -> SearchMatch | None:
+    if not matches:
+        return None
+
+    start_offset = location_to_offset(text, start_location)
+    for match in reversed(matches):
+        if location_to_offset(text, match.end) <= start_offset:
+            return match
+    return matches[-1]
+
+
+def load_document(path: Path) -> tuple[str, str]:
+    if not path.exists():
+        return "", "\n"
+
+    with path.open("r", encoding="utf-8", newline="") as file:
+        try:
+            raw_text = file.read()
+        except UnicodeDecodeError:
+            raise OSError(f"{path.name}: not a text file (binary or non-UTF-8 encoding)")
+
+    return normalize_newlines(raw_text), detect_newline(raw_text)
+
+
+def save_document(path: Path, text: str, newline: str) -> None:
+    path.parent.mkdir(parents=True, exist_ok=True)
+    payload = text if newline == "\n" else text.replace("\n", newline)
+
+    with NamedTemporaryFile(
+        "w",
+        encoding="utf-8",
+        newline="",
+        delete=False,
+        dir=path.parent,
+    ) as temp_file:
+        temp_file.write(payload)
+        temp_file.flush()
+        os.fsync(temp_file.fileno())
+        temp_path = Path(temp_file.name)
+
+    temp_path.replace(path)
+
+
+def language_for_path(path: Path | None) -> str | None:
+    if path is None:
+        return "python"
+
+    language_map = {
+        ".bash": "bash",
+        ".c": "c",
+        ".css": "css",
+        ".go": "go",
+        ".htm": "html",
+        ".html": "html",
+        ".java": "java",
+        ".js": "javascript",
+        ".json": "json",
+        ".jsx": "javascript",
+        ".md": "markdown",
+        ".py": "python",
+        ".rs": "rust",
+        ".sh": "bash",
+        ".sql": "sql",
+        ".toml": "toml",
+        ".ts": "javascript",
+        ".tsx": "javascript",
+        ".xml": "xml",
+        ".yaml": "yaml",
+        ".yml": "yaml",
+    }
+    return language_map.get(path.suffix.lower())
+
+
+def format_shortcuts() -> str:
+    return "\n".join(
+        [
+            "[b]jim shortcuts[/b]",
+            "",
+            "F1             help",
+            "Ctrl+S         save",
+            "Ctrl+Q         quit",
+            "Ctrl+F         search",
+            "Ctrl+G         search next",
+            "Ctrl+R         search previous",
+            "Ctrl+L         goto line",
+            "Ctrl+N         new buffer",
+            "Ctrl+O         open file browser",
+            "Ctrl+B         close buffer",
+            "Ctrl+PgDn      next buffer",
+            "Ctrl+PgUp      previous buffer",
+            "Ctrl+Space / Ctrl+@    toggle mark mode",
+            "Ctrl+A         start of line",
+            "Ctrl+E         end of line",
+            "Ctrl+Home      start of file",
+            "Ctrl+End       end of file",
+            "Ctrl+C         copy",
+            "Ctrl+X         cut",
+            "Ctrl+V         paste",
+            "Arrow keys     move cursor",
+            "Tab            insert tab",
+            "Backspace      delete left",
+            "Delete         delete right",
+            "Esc            close help/search dialogs",
+        ],
+    )
+
+
+class SearchDialog(ModalScreen[SearchRequest | None]):
+    BINDINGS = [Binding("escape", "cancel", "Cancel", show=False)]
+
+    def compose(self) -> ComposeResult:
+        yield Vertical(
+            Static("Search file", classes="dialog-title"),
+            Input(id="query", placeholder="Search text or regex"),
+            Checkbox("Regex", value=False, id="regex"),
+            Horizontal(
+                Button("Search", id="search", variant="primary"),
+                Button("Cancel", id="cancel"),
+            ),
+            classes="dialog",
+        )
+
+    def on_mount(self) -> None:
+        self.query_one(Input).focus()
+
+    def action_cancel(self) -> None:
+        self.dismiss(None)
+
+    def on_input_submitted(self, _: Input.Submitted) -> None:
+        self._submit()
+
+    def on_button_pressed(self, event: Button.Pressed) -> None:
+        if event.button.id == "search":
+            self._submit()
+        else:
+            self.dismiss(None)
+
+    def _submit(self) -> None:
+        query = self.query_one(Input).value.strip()
+        regex = self.query_one("#regex", Checkbox).value
+        self.dismiss(SearchRequest(query=query, regex=regex))
+
+
+class GotoLineDialog(ModalScreen[int | None]):
+    BINDINGS = [Binding("escape", "cancel", "Cancel", show=False)]
+
+    def compose(self) -> ComposeResult:
+        yield Vertical(
+            Static("Go to line", classes="dialog-title"),
+            Input(id="line", placeholder="Line number", restrict="0123456789"),
+            Horizontal(
+                Button("Go", id="go", variant="primary"),
+                Button("Cancel", id="cancel"),
+            ),
+            classes="dialog",
+        )
+
+    def on_mount(self) -> None:
+        self.query_one(Input).focus()
+
+    def action_cancel(self) -> None:
+        self.dismiss(None)
+
+    def on_input_submitted(self, _: Input.Submitted) -> None:
+        self._submit()
+
+    def on_button_pressed(self, event: Button.Pressed) -> None:
+        if event.button.id == "go":
+            self._submit()
+        else:
+            self.dismiss(None)
+
+    def _submit(self) -> None:
+        value = self.query_one(Input).value.strip()
+        try:
+            self.dismiss(int(value))
+        except ValueError:
+            self.dismiss(None)
+
+
+class PathDialog(ModalScreen[str | None]):
+    BINDINGS = [Binding("escape", "cancel", "Cancel", show=False)]
+
+    def __init__(self, title: str, placeholder: str, *, confirm_label: str = "Open") -> None:
+        super().__init__()
+        self._title = title
+        self._placeholder = placeholder
+        self._confirm_label = confirm_label
+
+    def compose(self) -> ComposeResult:
+        yield Vertical(
+            Static(self._title, classes="dialog-title"),
+            Input(id="path", placeholder=self._placeholder),
+            Horizontal(
+                Button(self._confirm_label, id="open", variant="primary"),
+                Button("Cancel", id="cancel"),
+            ),
+            classes="dialog",
+        )
+
+    def on_mount(self) -> None:
+        self.query_one(Input).focus()
+
+    def action_cancel(self) -> None:
+        self.dismiss(None)
+
+    def on_input_submitted(self, _: Input.Submitted) -> None:
+        self._submit()
+
+    def on_button_pressed(self, event: Button.Pressed) -> None:
+        if event.button.id == "open":
+            self._submit()
+        else:
+            self.dismiss(None)
+
+    def _submit(self) -> None:
+        value = self.query_one(Input).value.strip()
+        self.dismiss(value or None)
+
+
+class FileBrowserDialog(ModalScreen[Path | None]):
+    BINDINGS = [Binding("escape", "cancel", "Cancel", show=False)]
+
+    def __init__(self, start_path: Path) -> None:
+        super().__init__()
+        self._start_path = start_path
+        self._selected_path: Path | None = None
+        self._status: Static | None = None
+
+    def compose(self) -> ComposeResult:
+        yield Vertical(
+            Static(f"Open file from {self._start_path}", classes="dialog-title"),
+            DirectoryTree(self._start_path, id="file-browser"),
+            Static(
+                "Select a file to open. Use arrows to navigate; Enter expands folders.",
+                id="browser-status",
+            ),
+            Horizontal(
+                Button("Open", id="open", variant="primary"),
+                Button("Cancel", id="cancel"),
+            ),
+            classes="dialog file-browser-dialog",
+        )
+
+    def on_mount(self) -> None:
+        self._status = self.query_one("#browser-status", Static)
+        self.query_one(DirectoryTree).focus()
+
+    def action_cancel(self) -> None:
+        self.dismiss(None)
+
+    def on_directory_tree_file_selected(self, event: DirectoryTree.FileSelected) -> None:
+        self._selected_path = event.path
+        self.dismiss(event.path)
+
+    def on_directory_tree_directory_selected(self, event: DirectoryTree.DirectorySelected) -> None:
+        self._selected_path = event.path
+        if self._status is not None:
+            self._status.update(f"Selected folder: {event.path}")
+
+    def on_button_pressed(self, event: Button.Pressed) -> None:
+        if event.button.id == "open":
+            self.dismiss(self._selected_path)
+        else:
+            self.dismiss(None)
+
+
+class HelpDialog(ModalScreen[None]):
+    BINDINGS = [Binding("escape", "dismiss_help", "Close", show=False)]
+
+    def compose(self) -> ComposeResult:
+        yield Vertical(
+            Static("Help", classes="dialog-title"),
+            Static(format_shortcuts(), id="help-body"),
+            Button("Close", id="close", variant="primary"),
+            classes="dialog help-dialog",
+        )
+
+    def on_mount(self) -> None:
+        self.query_one(Button).focus()
+
+    def action_dismiss_help(self) -> None:
+        self.dismiss(None)
+
+    def on_button_pressed(self, _: Button.Pressed) -> None:
+        self.dismiss(None)
+
+
+class ConfirmDialog(ModalScreen[bool]):
+    BINDINGS = [Binding("escape", "cancel", "Cancel", show=False)]
+
+    def __init__(self, message: str) -> None:
+        super().__init__()
+        self._message = message
+
+    def compose(self) -> ComposeResult:
+        yield Vertical(
+            Static(self._message, classes="dialog-title"),
+            Horizontal(
+                Button("Yes", id="yes", variant="warning"),
+                Button("No", id="no", variant="primary"),
+            ),
+            classes="dialog",
+        )
+
+    def on_mount(self) -> None:
+        self.query_one("#no", Button).focus()
+
+    def action_cancel(self) -> None:
+        self.dismiss(False)
+
+    def on_button_pressed(self, event: Button.Pressed) -> None:
+        self.dismiss(event.button.id == "yes")
+
+
+class JimTextArea(TextArea):
+    BINDINGS = TextArea.BINDINGS + [
+        Binding("ctrl+@", "toggle_mark_mode", "Toggle mark mode", show=True),
+        Binding("ctrl+space", "toggle_mark_mode", "Toggle mark mode", show=False),
+        Binding("ctrl+home", "document_start", "Start of file", show=True),
+        Binding("ctrl+end", "document_end", "End of file", show=True),
+    ]
+
+    def __init__(self, *args, **kwargs) -> None:
+        self._search_query = ""
+        self._search_regex = False
+        super().__init__(*args, **kwargs)
+
+    def _build_highlight_map(self) -> None:
+        super()._build_highlight_map()
+        if not getattr(self, "_search_query", ""):
+            return
+
+        for match in find_search_matches(self.text, self._search_query, regex=self._search_regex):
+            self._add_search_highlight(match)
+
+    def _add_search_highlight(self, match: SearchMatch) -> None:
+        highlights = self._highlights
+        start_row, start_column = match.start
+        end_row, end_column = match.end
+        if start_row == end_row:
+            highlights[start_row].append((start_column, end_column, SEARCH_HIGHLIGHT_NAME))
+            return
+
+        highlights[start_row].append((start_column, None, SEARCH_HIGHLIGHT_NAME))
+        for row in range(start_row + 1, end_row):
+            highlights[row].append((0, None, SEARCH_HIGHLIGHT_NAME))
+        highlights[end_row].append((0, end_column, SEARCH_HIGHLIGHT_NAME))
+
+    def set_search(self, query: str, regex: bool) -> None:
+        self._search_query = query
+        self._search_regex = regex
+        self._build_highlight_map()
+        self.refresh()
+
+    def clear_search(self) -> None:
+        self.set_search("", False)
+
+    def action_toggle_mark_mode(self) -> None:
+        app = self.app
+        if isinstance(app, JimApp):
+            app.toggle_mark_mode()
+
+    def action_cursor_left(self, select: bool = False) -> None:
+        super().action_cursor_left(select=select or self._mark_mode())
+
+    def action_cursor_right(self, select: bool = False) -> None:
+        super().action_cursor_right(select=select or self._mark_mode())
+
+    def action_cursor_up(self, select: bool = False) -> None:
+        super().action_cursor_up(select=select or self._mark_mode())
+
+    def action_cursor_down(self, select: bool = False) -> None:
+        super().action_cursor_down(select=select or self._mark_mode())
+
+    def action_cursor_line_start(self, select: bool = False) -> None:
+        if not self._has_cursor:
+            self.scroll_home()
+            return
+        target = self.get_cursor_line_start_location(smart_home=True)
+        self.move_cursor(target, select=select or self._mark_mode())
+
+    def action_cursor_line_end(self, select: bool = False) -> None:
+        if not self._has_cursor:
+            self.scroll_end()
+            return
+        target = self.get_cursor_line_end_location()
+        self.move_cursor(target, select=select or self._mark_mode())
+
+    def action_cursor_page_up(self, select: bool = False) -> None:
+        if not self.show_cursor:
+            self.scroll_page_up()
+            return
+        height = self.content_size.height
+        _, cursor_location = self.selection
+        target = self.navigator.get_location_at_y_offset(cursor_location, -height)
+        self.scroll_relative(y=-height, animate=False)
+        self.move_cursor(target, select=select or self._mark_mode())
+
+    def action_cursor_page_down(self, select: bool = False) -> None:
+        if not self.show_cursor:
+            self.scroll_page_down()
+            return
+        height = self.content_size.height
+        _, cursor_location = self.selection
+        target = self.navigator.get_location_at_y_offset(cursor_location, height)
+        self.scroll_relative(y=height, animate=False)
+        self.move_cursor(target, select=select or self._mark_mode())
+
+    def action_document_start(self, select: bool = False) -> None:
+        self.move_cursor((0, 0), select=select or self._mark_mode())
+
+    def action_document_end(self, select: bool = False) -> None:
+        self.move_cursor(end_location(self.text), select=select or self._mark_mode())
+
+    def _mark_mode(self) -> bool:
+        app = self.app
+        return isinstance(app, JimApp) and app.mark_mode
+
+
+class BufferTab(TabPane):
+    def __init__(
+        self,
+        *,
+        title: str,
+        text: str,
+        file_path: Path | None,
+        newline: str,
+        language: str | None,
+        pane_id: str,
+    ) -> None:
+        editor = JimTextArea(
+            text,
+            language=language,
+            id=f"editor-{pane_id}",
+            soft_wrap=False,
+            tab_behavior="indent",
+            show_line_numbers=True,
+            highlight_cursor_line=True,
+            compact=True,
+        )
+        super().__init__(title, editor, id=pane_id)
+        self.file_path = file_path
+        self.newline = newline
+        self.saved_text = text
+        self._language = language
+
+    @property
+    def editor(self) -> JimTextArea:
+        return self.query_one(JimTextArea)
+
+
+class JimApp(App[None]):
+    CSS = """
+    Screen {
+        layout: vertical;
+    }
+
+    #buffers {
+        width: 1fr;
+        height: 1fr;
+    }
+
+    #status {
+        height: auto;
+        border-top: solid $accent;
+        padding: 0 1;
+        background: $panel;
+    }
+
+    .dialog {
+        width: 70;
+        padding: 1 2;
+        border: round $accent;
+        background: $surface;
+    }
+
+    .help-dialog {
+        height: auto;
+    }
+
+    .dialog-title {
+        padding-bottom: 1;
+        text-style: bold;
+    }
+
+    #help-body {
+        height: auto;
+        padding-bottom: 1;
+    }
+    """
+
+    BINDINGS = [
+        Binding("ctrl+s", "save_file", "Save", show=True),
+        Binding("ctrl+q", "safe_quit", "Quit", show=True),
+        Binding("ctrl+f", "search", "Search", show=True),
+        Binding("ctrl+g", "search_next", "Search next", show=True),
+        Binding("ctrl+r", "search_previous", "Search previous", show=True),
+        Binding("ctrl+l", "goto_line", "Go to line", show=True),
+        Binding("ctrl+n", "new_buffer", "New buffer", show=True),
+        Binding("ctrl+o", "open_file", "Open file", show=True),
+        Binding("ctrl+b", "close_buffer", "Close buffer", show=True),
+        Binding("f1", "show_help", "Help", show=True),
+        Binding("ctrl+pagedown", "next_buffer", "Next buffer", show=True),
+        Binding("ctrl+pageup", "previous_buffer", "Previous buffer", show=True),
+    ]
+
+    def __init__(self, file_path: Path | None = None) -> None:
+        super().__init__()
+        self.start_path = file_path.expanduser() if file_path is not None else None
+        self.status_message = "Ready"
+        self.mark_mode = False
+        self._clipboard_text = ""
+        self._buffers: TabbedContent | None = None
+        self._status: Static | None = None
+        self._buffer_serial = 0
+
+    def compose(self) -> ComposeResult:
+        yield TabbedContent(id="buffers")
+        yield Static("", id="status")
+
+    def on_mount(self) -> None:
+        self._buffers = self.query_one(TabbedContent)
+        self._status = self.query_one("#status", Static)
+
+        if self.start_path is not None:
+            self.open_buffer(self.start_path)
+        else:
+            self.open_buffer(None)
+
+        self.refresh_status()
+
+    def on_tabbed_content_tab_activated(self, _: TabbedContent.TabActivated) -> None:
+        self.focus_active_editor()
+        self.refresh_status()
+
+    def on_text_area_changed(self, _: TextArea.Changed) -> None:
+        self.refresh_status()
+
+    def on_text_area_selection_changed(self, _: TextArea.SelectionChanged) -> None:
+        self.refresh_status()
+
+    @property
+    def clipboard(self) -> str:
+        try:
+            return pyperclip.paste()
+        except pyperclip.PyperclipException:
+            return self._clipboard_text
+
+    def copy_to_clipboard(self, text: str) -> None:
+        self._clipboard_text = text
+        try:
+            pyperclip.copy(text)
+        except pyperclip.PyperclipException:
+            try:
+                super().copy_to_clipboard(text)
+            except Exception:
+                pass
+            self.status_message = "Clipboard unavailable; kept a local copy"
+        else:
+            self.status_message = "Copied to system clipboard"
+        self.refresh_status()
+
+    def active_pane(self) -> BufferTab | None:
+        buffers = self._buffers
+        if buffers is None:
+            return None
+        active = buffers.active_pane
+        return active if isinstance(active, BufferTab) else None
+
+    def active_editor(self) -> JimTextArea | None:
+        pane = self.active_pane()
+        return pane.editor if pane is not None else None
+
+    def focus_active_editor(self) -> None:
+        editor = self.active_editor()
+        if editor is not None:
+            editor.focus()
+
+    def buffer_label(self, path: Path | None) -> str:
+        if path is None:
+            return f"Untitled {self._buffer_serial + 1}"
+        return path.name
+
+    def open_buffer(self, path: Path | None) -> None:
+        buffers = self._buffers
+        if buffers is None:
+            return
+
+        if path is not None:
+            for pane in self.query(BufferTab):
+                if pane.file_path == path:
+                    buffers.active = pane.id or ""
+                    self.status_message = f"Focused {path}"
+                    self.focus_active_editor()
+                    return
+
+        if path is None:
+            text = ""
+            newline = "\n"
+            language = "python"
+            resolved_path = None
+        else:
+            try:
+                text, newline = load_document(path)
+            except OSError as error:
+                self.status_message = f"Cannot open: {error}"
+                self.refresh_status()
+                return
+            language = language_for_path(path)
+            resolved_path = path
+
+        pane_id = f"buffer-{self._buffer_serial}"
+        self._buffer_serial += 1
+        pane = BufferTab(
+            title=self.buffer_label(path),
+            text=text,
+            file_path=resolved_path,
+            newline=newline,
+            language=language,
+            pane_id=pane_id,
+        )
+        buffers.add_pane(pane)
+        buffers.active = pane_id
+        self.status_message = f"Opened {path}" if path is not None else "New buffer"
+        self.focus_active_editor()
+
+    def close_active_buffer(self) -> None:
+        buffers = self._buffers
+        pane = self.active_pane()
+        if buffers is None or pane is None:
+            return
+        if buffers.tab_count <= 1:
+            self.status_message = "At least one buffer must remain open"
+            self.refresh_status()
+            return
+
+        next_panes = [candidate for candidate in self.query(BufferTab) if candidate is not pane]
+        next_active = next_panes[0] if next_panes else None
+        pane.remove()
+        if next_active is not None:
+            buffers.active = next_active.id or ""
+        self.focus_active_editor()
+        self.status_message = "Closed buffer"
+
+    def toggle_mark_mode(self) -> None:
+        self.mark_mode = not self.mark_mode
+        self.status_message = "Mark mode on" if self.mark_mode else "Mark mode off"
+        self.refresh_status()
+
+    def action_show_help(self) -> None:
+        self.push_screen(HelpDialog())
+
+    def action_search(self) -> None:
+        self.push_screen(SearchDialog(), self._apply_search)
+
+    def action_search_next(self) -> None:
+        editor = self.active_editor()
+        if editor is None or not editor._search_query:
+            self.status_message = "No previous search to repeat"
+            self.refresh_status()
+            return
+
+        self._jump_to_search_match(forward=True)
+
+    def action_search_previous(self) -> None:
+        editor = self.active_editor()
+        if editor is None or not editor._search_query:
+            self.status_message = "No previous search to repeat"
+            self.refresh_status()
+            return
+
+        self._jump_to_search_match(forward=False)
+
+    def action_goto_line(self) -> None:
+        self.push_screen(GotoLineDialog(), self._apply_goto_line)
+
+    def action_new_buffer(self) -> None:
+        self.open_buffer(None)
+        self.refresh_status()
+
+    def action_open_file(self) -> None:
+        self.push_screen(FileBrowserDialog(Path.cwd()), self._apply_open_file)
+
+    def action_close_buffer(self) -> None:
+        pane = self.active_pane()
+        editor = self.active_editor()
+        if pane is not None and editor is not None and editor.text != pane.saved_text:
+            self.push_screen(
+                ConfirmDialog("This buffer has unsaved changes. Close anyway?"),
+                self._apply_close_confirm,
+            )
+        else:
+            self.close_active_buffer()
+            self.refresh_status()
+
+    def _apply_close_confirm(self, confirmed: bool) -> None:
+        if confirmed:
+            self.close_active_buffer()
+            self.refresh_status()
+
+    def action_safe_quit(self) -> None:
+        dirty = [p for p in self.query(BufferTab) if p.editor.text != p.saved_text]
+        if dirty:
+            count = len(dirty)
+            noun = "buffer" if count == 1 else "buffers"
+            self.push_screen(
+                ConfirmDialog(f"{count} {noun} with unsaved changes. Quit anyway?"),
+                self._apply_quit_confirm,
+            )
+        else:
+            self.exit()
+
+    def _apply_quit_confirm(self, confirmed: bool) -> None:
+        if confirmed:
+            self.exit()
+
+    def action_next_buffer(self) -> None:
+        self._cycle_buffer(1)
+
+    def action_previous_buffer(self) -> None:
+        self._cycle_buffer(-1)
+
+    def action_save_file(self) -> None:
+        pane = self.active_pane()
+        editor = self.active_editor()
+        if pane is None or editor is None:
+            return
+        if pane.file_path is None:
+            self.push_screen(
+                PathDialog("Save as", "Enter file path", confirm_label="Save"),
+                self._apply_save_as,
+            )
+            return
+        self._do_save(pane, editor)
+
+    def _do_save(self, pane: BufferTab, editor: JimTextArea) -> None:
+        try:
+            save_document(pane.file_path, editor.text, pane.newline)
+        except OSError as error:
+            self.status_message = f"Save failed: {error}"
+        else:
+            pane.saved_text = editor.text
+            self.status_message = f"Saved {pane.file_path}"
+        self.refresh_status()
+
+    def _apply_save_as(self, value: str | None) -> None:
+        if value is None:
+            self.status_message = "Save cancelled"
+            self.refresh_status()
+            return
+        pane = self.active_pane()
+        editor = self.active_editor()
+        if pane is None or editor is None:
+            return
+        path = Path(value).expanduser()
+        try:
+            save_document(path, editor.text, pane.newline)
+        except OSError as error:
+            self.status_message = f"Save failed: {error}"
+        else:
+            pane.file_path = path
+            pane.saved_text = editor.text
+            self.status_message = f"Saved {path}"
+        self.refresh_status()
+
+    def _jump_to_search_match(self, *, forward: bool) -> None:
+        editor = self.active_editor()
+        if editor is None or not editor._search_query:
+            return
+
+        matches = find_search_matches(editor.text, editor._search_query, regex=editor._search_regex)
+        if not matches:
+            self.status_message = f"No match for {editor._search_query!r}"
+            self.refresh_status()
+            return
+
+        current_location = editor.cursor_location
+        match = (
+            find_next_search_match(editor.text, matches, current_location)
+            if forward
+            else find_previous_search_match(editor.text, matches, current_location)
+        )
+        if match is None:
+            self.status_message = f"No match for {editor._search_query!r}"
+            self.refresh_status()
+            return
+
+        editor.move_cursor(match.start)
+        editor.move_cursor(match.end, select=True)
+        self.status_message = f"Found {editor._search_query!r}"
+        self.refresh_status()
+
+    def _apply_search(self, result: SearchRequest | None) -> None:
+        if result is None:
+            self.status_message = "Search cancelled"
+            self.refresh_status()
+            return
+        pane = self.active_pane()
+        editor = self.active_editor()
+        if pane is None:
+            return
+        if editor is not None:
+            editor.set_search(result.query, result.regex)
+        self._run_search(result.query, result.regex)
+
+    def _run_search(self, query: str, regex: bool) -> None:
+        editor = self.active_editor()
+        if editor is None:
+            return
+
+        try:
+            match = search_document(
+                editor.text,
+                query,
+                regex=regex,
+                start_location=editor.cursor_location,
+            )
+        except re.error as error:
+            self.status_message = f"Invalid regex: {error}"
+            self.refresh_status()
+            return
+
+        if match is None:
+            self.status_message = f"No match for {query!r}"
+            self.refresh_status()
+            return
+
+        editor.move_cursor(match.start)
+        editor.move_cursor(match.end, select=True)
+        self.status_message = f"Found {query!r}"
+        self.refresh_status()
+
+    def _apply_goto_line(self, line_number: int | None) -> None:
+        if line_number is None:
+            self.status_message = "Goto cancelled"
+            self.refresh_status()
+            return
+        editor = self.active_editor()
+        if editor is None:
+            return
+        editor.move_cursor(goto_line_location(editor.text, line_number))
+        self.status_message = f"Moved to line {line_number}"
+        self.refresh_status()
+
+    def _apply_open_file(self, value: Path | None) -> None:
+        if value is None:
+            self.status_message = "Open cancelled"
+            self.refresh_status()
+            return
+        self.open_buffer(value.expanduser())
+        self.refresh_status()
+
+    def _cycle_buffer(self, step: int) -> None:
+        panes = list(self.query(BufferTab))
+        if len(panes) <= 1:
+            return
+        active = self.active_pane()
+        if active is None:
+            return
+        index = panes.index(active)
+        next_pane = panes[(index + step) % len(panes)]
+        buffers = self._buffers
+        if buffers is not None:
+            buffers.active = next_pane.id or ""
+        self.focus_active_editor()
+        self.refresh_status()
+
+    def refresh_status(self) -> None:
+        status = self._status
+        if status is not None:
+            status.update(self.build_status_line())
+
+    def build_status_line(self) -> str:
+        pane = self.active_pane()
+        editor = self.active_editor()
+        if pane is None or editor is None:
+            return f"{self.status_message} | Help F1"
+
+        row, column = editor.cursor_location
+        selection_text = editor.selected_text
+        selection_state = "on" if self.mark_mode else "off"
+        selection_label = f"{len(selection_text)} chars" if selection_text else "none"
+        dirty_state = "modified" if editor.text != pane.saved_text else "saved"
+        newline_label = {"\n": "LF", "\r\n": "CRLF", "\r": "CR"}.get(pane.newline, "LF")
+        file_label = str(pane.file_path) if pane.file_path is not None else "Untitled"
+        return (
+            f"{file_label} | Ln {row + 1}, Col {column + 1} | "
+            f"mark {selection_state} | sel {selection_label} | {dirty_state} | {newline_label} | "
+            f"{self.status_message} | Help F1"
+        )
+
+
+def main(argv: list[str] | None = None) -> int:
+    parser = argparse.ArgumentParser(prog="jim", description="A small terminal text editor")
+    parser.add_argument("path", nargs="?", type=Path, help="file to edit")
+    parsed_args = parser.parse_args(argv)
+
+    JimApp(parsed_args.path).run()
+    return 0

jim_editor-0.1.0/src/jim_editor.egg-info/PKG-INFO

@@ -0,0 +1,22 @@
+Metadata-Version: 2.4
+Name: jim_editor
+Version: 0.1.0
+Summary: A fast, simple terminal text editor
+Requires-Python: >=3.14
+Requires-Dist: pyperclip>=1.9
+Requires-Dist: textual>=8.2
+Requires-Dist: tree-sitter>=0.23
+Requires-Dist: tree-sitter-python
+Requires-Dist: tree-sitter-javascript
+Requires-Dist: tree-sitter-yaml
+Requires-Dist: tree-sitter-html
+Requires-Dist: tree-sitter-go
+Requires-Dist: tree-sitter-rust
+Requires-Dist: tree-sitter-json
+Requires-Dist: tree-sitter-toml
+Requires-Dist: tree-sitter-bash
+Requires-Dist: tree-sitter-xml
+Requires-Dist: tree-sitter-css
+Requires-Dist: tree-sitter-java
+Requires-Dist: tree-sitter-markdown
+Requires-Dist: tree-sitter-sql

jim_editor-0.1.0/src/jim_editor.egg-info/SOURCES.txt

@@ -0,0 +1,11 @@
+pyproject.toml
+src/jim_editor/__init__.py
+src/jim_editor/__main__.py
+src/jim_editor/app.py
+src/jim_editor.egg-info/PKG-INFO
+src/jim_editor.egg-info/SOURCES.txt
+src/jim_editor.egg-info/dependency_links.txt
+src/jim_editor.egg-info/entry_points.txt
+src/jim_editor.egg-info/requires.txt
+src/jim_editor.egg-info/top_level.txt
+tests/test_app.py

jim_editor-0.1.0/src/jim_editor.egg-info/dependency_links.txt

@@ -0,0 +1 @@
+

jim_editor-0.1.0/src/jim_editor.egg-info/entry_points.txt

@@ -0,0 +1,2 @@
+[console_scripts]
+jim_editor = jim_editor.__main__:main

jim_editor-0.1.0/src/jim_editor.egg-info/requires.txt

@@ -0,0 +1,17 @@
+pyperclip>=1.9
+textual>=8.2
+tree-sitter>=0.23
+tree-sitter-python
+tree-sitter-javascript
+tree-sitter-yaml
+tree-sitter-html
+tree-sitter-go
+tree-sitter-rust
+tree-sitter-json
+tree-sitter-toml
+tree-sitter-bash
+tree-sitter-xml
+tree-sitter-css
+tree-sitter-java
+tree-sitter-markdown
+tree-sitter-sql

jim_editor-0.1.0/src/jim_editor.egg-info/top_level.txt

@@ -0,0 +1 @@
+jim_editor

jim_editor-0.1.0/tests/test_app.py

@@ -0,0 +1,108 @@
+from pathlib import Path
+
+from jim_editor.app import (
+    detect_newline,
+    end_location,
+    find_next_search_match,
+    find_previous_search_match,
+    find_search_matches,
+    format_shortcuts,
+    goto_line_location,
+    load_document,
+    normalize_newlines,
+    save_document,
+    search_document,
+)
+
+
+def test_end_location_handles_empty_and_trailing_newline() -> None:
+    assert end_location("") == (0, 0)
+    assert end_location("hello") == (0, 5)
+    assert end_location("hello\n") == (1, 0)
+
+
+def test_newline_helpers_normalize_and_detect() -> None:
+    assert normalize_newlines("a\r\nb\rc") == "a\nb\nc"
+    assert detect_newline("a\r\nb") == "\r\n"
+    assert detect_newline("a\rb") == "\r"
+    assert detect_newline("a\nb") == "\n"
+
+
+def test_document_round_trip_preserves_newline_style(tmp_path: Path) -> None:
+    path = tmp_path / "sample.txt"
+    path.write_bytes(b"line1\r\nline2\r\n")
+
+    text, newline = load_document(path)
+    assert text == "line1\nline2\n"
+    assert newline == "\r\n"
+
+    save_document(path, text, newline)
+    assert path.read_bytes() == b"line1\r\nline2\r\n"
+
+
+def test_format_shortcuts_includes_required_actions() -> None:
+    cheatsheet = format_shortcuts()
+    required = [
+        "Ctrl+S",
+        "Ctrl+Q",
+        "Ctrl+F",
+        "Ctrl+L",
+        "Ctrl+O",
+        "Ctrl+N",
+        "Ctrl+B",
+        "Ctrl+Home",
+        "Ctrl+End",
+        "Ctrl+R",
+        "Ctrl+PgDn",
+        "Ctrl+PgUp",
+    ]
+    for label in required:
+        assert label in cheatsheet
+
+    non_empty_lines = [line for line in cheatsheet.splitlines() if line.strip()]
+    assert len(non_empty_lines) == len(set(non_empty_lines))
+
+
+def test_language_for_path_maps_major_languages() -> None:
+    from jim_editor.app import language_for_path
+
+    assert language_for_path(Path("demo.py")) == "python"
+    assert language_for_path(Path("demo.js")) == "javascript"
+    assert language_for_path(Path("demo.ts")) == "javascript"
+    assert language_for_path(Path("demo.tsx")) == "javascript"
+    assert language_for_path(Path("demo.jsx")) == "javascript"
+    assert language_for_path(Path("demo.yaml")) == "yaml"
+    assert language_for_path(Path("demo.html")) == "html"
+    assert language_for_path(Path("demo.go")) == "go"
+    assert language_for_path(None) == "python"
+    assert language_for_path(Path("demo.unknown")) is None
+
+
+def test_search_document_supports_plain_and_regex() -> None:
+    plain = search_document("alpha beta alpha", "beta")
+    assert plain is not None
+    assert plain.start == (0, 6)
+    assert plain.end == (0, 10)
+
+    regex = search_document("value=12\nvalue=99", r"value=\d+", regex=True, start_location=(1, 0))
+    assert regex is not None
+    assert regex.start == (1, 0)
+    assert regex.end == (1, 8)
+
+
+def test_find_search_matches_supports_forward_and_reverse_navigation() -> None:
+    text = "alpha beta alpha beta"
+    matches = find_search_matches(text, "beta")
+    assert len(matches) == 2
+
+    assert find_next_search_match(text, matches, (0, 0)) == matches[0]
+    assert find_next_search_match(text, matches, (0, 12)) == matches[1]
+    assert find_previous_search_match(text, matches, (0, 12)) == matches[0]
+    assert find_previous_search_match(text, matches, (0, 0)) == matches[-1]
+
+
+def test_goto_line_location_clamps_to_file_bounds() -> None:
+    text = "one\ntwo\nthree"
+    assert goto_line_location(text, 1) == (0, 0)
+    assert goto_line_location(text, 2) == (1, 0)
+    assert goto_line_location(text, 99) == (2, 5)