tlex 1.0.0__tar.gz

tlex-1.0.0/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Viki | Vignesh
+
+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.

tlex-1.0.0/PKG-INFO

@@ -0,0 +1,137 @@
+Metadata-Version: 2.4
+Name: tlex
+Version: 1.0.0
+Summary: A safe line editor and viewer for the terminal.
+License-Expression: MIT
+Requires-Python: >=3.9
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Dynamic: license-file
+
+# tlex
+
+**A safe line editor and viewer for the terminal.**
+
+tlex is built around one idea: you should never change a file by accident.
+Opening a file is read-only viewing. A change only happens when you deliberately
+open **one line** in a small popup, edit it, and confirm with Enter.
+Everything is undoable, and nothing is written until you say so.
+
+It looks like old vim: plain text, no colour clutter, a bar on the current line,
+and `:wq` to save and quit. Pure Python, standard library only.
+
+```
+ alpha
+ beta                                  <- current line (bar)
+ gamma
+ ~
+                                        
+ ┌─────────────────────────────────────────────────────────────┬──────┬───────────┐
+ │ notes.txt [+]                                               │ VIEW │ Line: 2/3 │
+ ├──────────────┬──────────────┬──────────────┬────────────────┴──────┴───────────┤
+ │ edit     [e] │ insert   [i] │ delete   [d] │ copy      [y]  ...                │
+ └──────────────┴──────────────┴──────────────┴───────────────────────────────────┘
+```
+
+## Features
+
+- **Safe by design:** view mode is read-only; unknown keys do nothing.
+- **One line at a time:** edit happens in a popup placed on the line itself.
+- **Insert between lines:** `i` adds a new line below the current one and opens it for editing. Esc removes it again.
+- **Undo** for every change; **delete and paste ask first** (`[y]` = yes, any other key = no).
+- **Copy and paste:** copy a line to the system clipboard, put it back with `p`, or paste from the terminal (multi-line paste is detected as one block and asks before inserting).
+- **Atomic saves:** written to a temp file and renamed, permissions kept. CRLF files and a missing final newline are preserved.
+- **`:q` protects your work:** it refuses to quit with unsaved changes; `:q!` discards on purpose.
+- **Configurable:** keys (several per operation), hint table, padding and popup colour are all set in one block at the top of the file.
+- **Optional line numbers** (off by default), read-only mode, UTF-8 and wide characters.
+
+## Install
+
+### With pipx
+
+```bash
+pipx install git+https://github.com/datatalisman/tlex
+```
+
+### From a clone of the repo
+
+```bash
+git clone https://github.com/datatalisman/tlex
+cd tlex
+./install.sh
+```
+
+### Uninstall
+
+```bash
+./uninstall.sh          # from the repo directory
+# or, if you used pipx directly:
+pipx uninstall tlex
+```
+
+**Requirements:** Python 3 and a terminal on Linux or macOS (it uses `curses`; Windows is not supported).
+For copying to the system clipboard it uses `wl-copy`, `xclip` or `xsel` if available, and falls back to the terminal's OSC 52 clipboard.
+
+## Usage
+
+```bash
+tlex notes.txt        # edit (a missing file starts as a new file)
+tlex -R notes.txt     # view only, no editing possible
+```
+
+### View mode keys
+
+| Key | Action |
+|---|---|
+| `Up` `Down` `PageUp` `PageDown` | Move |
+| `Home` / `g`, `End` / `G` | Top / bottom |
+| `e`, `Enter` | Edit the current line (popup, cursor at the start) |
+| `i` | Insert a new line below, then edit it |
+| `d` | Delete the current line (asks first) |
+| `y`, `c` | Copy the current line |
+| `p` | Put the copied line below the current one |
+| `u` | Undo |
+| `n` | Toggle line numbers |
+| `:` | Command line |
+
+### Edit / insert popup
+
+| Key | Action |
+|---|---|
+| `Enter` | Save the line |
+| `Esc` | Discard (for `i`, the new line disappears) |
+| `Left` `Right` `Home` `End` | Move inside the line |
+| `Backspace` `Delete` | Erase |
+| terminal paste | Insert at the cursor (multi-line text is joined with spaces) |
+
+Up and Down are ignored in the popup on purpose, so you cannot leave the line by accident.
+
+### Commands (press `:`)
+
+| Command | Action |
+|---|---|
+| `:w` | Write |
+| `:wq` | Write and quit |
+| `:q` | Quit (refuses if there are unsaved changes) |
+| `:q!` | Quit and discard changes |
+| `:N` | Go to line N |
+
+`Esc` followed by `:` works as in vim.
+
+## Configuration
+
+Everything is in the **CONFIG** block at the top of `tlex.py`:
+
+- **`KEYS`:** operation → list of keys. Add as many keys as you like per operation, for example `"copy": ["y", "c"]`. Keys are characters (`"e"`, `":"`) or names (`Enter`, `Esc`, `Tab`, `Space`, `Backspace`, `Delete`, `Up`, `Down`, `Left`, `Right`, `PageUp`, `PageDown`, `Home`, `End`, `Ctrl-S`).
+- **`HINTS`:** the cells of the hint table at the bottom. They are generated from `KEYS`, so they update when you change a key. `HINT_SHOW_ALL_KEYS = True` shows every key of an operation (`[y/c]`) instead of the first one.
+- **`info_box_padding_top`, `_bottom`, `_left`, `_right`:** blank space around the info box.
+- **`popup_theme`:** colour of the popup, chosen from `POPUP_THEMES` (traditional Japanese colours): `ruri`, `kikyo`, `suo`, `rokusho`, `shinbashi`, `botan`, `fujimurasaki`, `yamabuki`. Add your own as `name: (background hex, text hex, description)`.
+
+After editing the config, reinstall (run `./install.sh` again) so the installed copy picks up the change.
+
+## Safety notes
+
+- tlex never modifies the file until you run `:w` or `:wq`.
+- Writes go to a temporary file in the same directory and are renamed over the original, so a crash cannot leave a half-written file.
+- The undo history lives only while the editor is open.
+- Files with bytes that are not valid UTF-8 are kept byte for byte; those bytes are shown as `·`.

tlex-1.0.0/README.md

@@ -0,0 +1,127 @@
+# tlex
+
+**A safe line editor and viewer for the terminal.**
+
+tlex is built around one idea: you should never change a file by accident.
+Opening a file is read-only viewing. A change only happens when you deliberately
+open **one line** in a small popup, edit it, and confirm with Enter.
+Everything is undoable, and nothing is written until you say so.
+
+It looks like old vim: plain text, no colour clutter, a bar on the current line,
+and `:wq` to save and quit. Pure Python, standard library only.
+
+```
+ alpha
+ beta                                  <- current line (bar)
+ gamma
+ ~
+                                        
+ ┌─────────────────────────────────────────────────────────────┬──────┬───────────┐
+ │ notes.txt [+]                                               │ VIEW │ Line: 2/3 │
+ ├──────────────┬──────────────┬──────────────┬────────────────┴──────┴───────────┤
+ │ edit     [e] │ insert   [i] │ delete   [d] │ copy      [y]  ...                │
+ └──────────────┴──────────────┴──────────────┴───────────────────────────────────┘
+```
+
+## Features
+
+- **Safe by design:** view mode is read-only; unknown keys do nothing.
+- **One line at a time:** edit happens in a popup placed on the line itself.
+- **Insert between lines:** `i` adds a new line below the current one and opens it for editing. Esc removes it again.
+- **Undo** for every change; **delete and paste ask first** (`[y]` = yes, any other key = no).
+- **Copy and paste:** copy a line to the system clipboard, put it back with `p`, or paste from the terminal (multi-line paste is detected as one block and asks before inserting).
+- **Atomic saves:** written to a temp file and renamed, permissions kept. CRLF files and a missing final newline are preserved.
+- **`:q` protects your work:** it refuses to quit with unsaved changes; `:q!` discards on purpose.
+- **Configurable:** keys (several per operation), hint table, padding and popup colour are all set in one block at the top of the file.
+- **Optional line numbers** (off by default), read-only mode, UTF-8 and wide characters.
+
+## Install
+
+### With pipx
+
+```bash
+pipx install git+https://github.com/datatalisman/tlex
+```
+
+### From a clone of the repo
+
+```bash
+git clone https://github.com/datatalisman/tlex
+cd tlex
+./install.sh
+```
+
+### Uninstall
+
+```bash
+./uninstall.sh          # from the repo directory
+# or, if you used pipx directly:
+pipx uninstall tlex
+```
+
+**Requirements:** Python 3 and a terminal on Linux or macOS (it uses `curses`; Windows is not supported).
+For copying to the system clipboard it uses `wl-copy`, `xclip` or `xsel` if available, and falls back to the terminal's OSC 52 clipboard.
+
+## Usage
+
+```bash
+tlex notes.txt        # edit (a missing file starts as a new file)
+tlex -R notes.txt     # view only, no editing possible
+```
+
+### View mode keys
+
+| Key | Action |
+|---|---|
+| `Up` `Down` `PageUp` `PageDown` | Move |
+| `Home` / `g`, `End` / `G` | Top / bottom |
+| `e`, `Enter` | Edit the current line (popup, cursor at the start) |
+| `i` | Insert a new line below, then edit it |
+| `d` | Delete the current line (asks first) |
+| `y`, `c` | Copy the current line |
+| `p` | Put the copied line below the current one |
+| `u` | Undo |
+| `n` | Toggle line numbers |
+| `:` | Command line |
+
+### Edit / insert popup
+
+| Key | Action |
+|---|---|
+| `Enter` | Save the line |
+| `Esc` | Discard (for `i`, the new line disappears) |
+| `Left` `Right` `Home` `End` | Move inside the line |
+| `Backspace` `Delete` | Erase |
+| terminal paste | Insert at the cursor (multi-line text is joined with spaces) |
+
+Up and Down are ignored in the popup on purpose, so you cannot leave the line by accident.
+
+### Commands (press `:`)
+
+| Command | Action |
+|---|---|
+| `:w` | Write |
+| `:wq` | Write and quit |
+| `:q` | Quit (refuses if there are unsaved changes) |
+| `:q!` | Quit and discard changes |
+| `:N` | Go to line N |
+
+`Esc` followed by `:` works as in vim.
+
+## Configuration
+
+Everything is in the **CONFIG** block at the top of `tlex.py`:
+
+- **`KEYS`:** operation → list of keys. Add as many keys as you like per operation, for example `"copy": ["y", "c"]`. Keys are characters (`"e"`, `":"`) or names (`Enter`, `Esc`, `Tab`, `Space`, `Backspace`, `Delete`, `Up`, `Down`, `Left`, `Right`, `PageUp`, `PageDown`, `Home`, `End`, `Ctrl-S`).
+- **`HINTS`:** the cells of the hint table at the bottom. They are generated from `KEYS`, so they update when you change a key. `HINT_SHOW_ALL_KEYS = True` shows every key of an operation (`[y/c]`) instead of the first one.
+- **`info_box_padding_top`, `_bottom`, `_left`, `_right`:** blank space around the info box.
+- **`popup_theme`:** colour of the popup, chosen from `POPUP_THEMES` (traditional Japanese colours): `ruri`, `kikyo`, `suo`, `rokusho`, `shinbashi`, `botan`, `fujimurasaki`, `yamabuki`. Add your own as `name: (background hex, text hex, description)`.
+
+After editing the config, reinstall (run `./install.sh` again) so the installed copy picks up the change.
+
+## Safety notes
+
+- tlex never modifies the file until you run `:w` or `:wq`.
+- Writes go to a temporary file in the same directory and are renamed over the original, so a crash cannot leave a half-written file.
+- The undo history lives only while the editor is open.
+- Files with bytes that are not valid UTF-8 are kept byte for byte; those bytes are shown as `·`.

tlex-1.0.0/pyproject.toml

@@ -0,0 +1,17 @@
+[build-system]
+requires = ["setuptools>=61"]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "tlex"
+version = "1.0.0"
+description = "A safe line editor and viewer for the terminal."
+readme = "README.md"
+requires-python = ">=3.9"
+license = "MIT"
+
+[project.scripts]
+tlex = "app.main:main"
+
+[tool.setuptools.packages.find]
+where = ["src"]

tlex-1.0.0/setup.cfg

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

tlex-1.0.0/src/app/__init__.py

@@ -0,0 +1 @@
+__version__ = "1.0.0"

tlex-1.0.0/src/app/main.py

@@ -0,0 +1,838 @@
+#!/usr/bin/env python3
+"""tlex - a safe line editor / viewer.
+
+Nothing changes unless you explicitly ask for it:
+  * VIEW mode is read-only; unknown keys do nothing.
+  * Only ONE line can be edited at a time, in a popup on that line.
+  * Every change is undoable; deletes and pastes ask first.
+  * Writes are atomic (temp file + rename); :q refuses to drop unsaved work.
+
+Usage:  tlex.py [-R] FILE        (-R = read-only viewer)
+
+All keys, the hint cells, the info-box padding and the popup colour are
+configured in the CONFIG section right below.  Commands (type ':'):
+  :w  write      :wq  write + quit      :q  quit      :q!  quit, discard      :N  go to line N
+Terminal paste (Ctrl+Shift+V) in view mode inserts the pasted lines below.
+"""
+import argparse
+import base64
+import curses
+import locale
+import os
+import shutil
+import subprocess
+import sys
+import tempfile
+import unicodedata
+
+# =====================================================================
+#  CONFIG  -  change anything in this block
+# =====================================================================
+
+# ---- Key mapping: operation -> list of keys (as many as you like) ----
+# A key is a single character ("e", "G", ":") or a name:
+#   Enter Esc Tab Space Backspace Delete Up Down Left Right PageUp PageDown Home End
+# or Ctrl-<letter>, e.g. "Ctrl-S".
+KEYS = {
+    # view mode
+    "edit":      ["e", "enter"],
+    "insert":    ["i"],            # new line below the current one, then edit it
+    "delete":    ["d"],
+    "copy":      ["y", "c"],       # example of two keys for one operation
+    "paste":     ["p"],
+    "undo":      ["u"],
+    "numbers":   ["n"],            # toggle line numbers
+    "command":   [":"],            # :w  :wq  :q  :q!  :N
+    "up":        ["Up"],
+    "down":      ["Down"],
+    "page_up":   ["PageUp"],
+    "page_down": ["PageDown"],
+    "top":       ["Home"],
+    "bottom":    ["End"],
+    # answers to "are you sure?" questions (any other key = no)
+    "yes":       ["y"],
+    # edit / insert popup
+    "save":      ["Enter"],
+    "discard":   ["Esc"],
+}
+
+# ---- Hint cells (bottom of the screen), generated from KEYS above ----
+# (label, operation-name-from-KEYS)  or  (label, ["literal", "keys"])
+HINTS = [
+    ("edit",    "edit"),
+    ("insert",  "insert"),
+    ("delete",  "delete"),
+    ("copy",    "copy"),
+    ("paste",   "paste"),
+    ("undo",    "undo"),
+    ("numbers", "numbers"),
+    ("command", "command"),
+    ("write",   [":w"]),
+    ("quit",    [":q"]),
+]
+HINT_SHOW_ALL_KEYS = False         # False: one key per cell (the first one); True: [y/c]
+HINT_KEY_SEPARATOR = "/"           # between keys when HINT_SHOW_ALL_KEYS is True
+
+popup_margin = 1        # columns left and right of the popup (about 0.5 cm)
+
+# ---- Info box (status + hint table at the bottom) ----
+info_box_padding_top = 0           # blank rows between file content and the box
+info_box_padding_bottom = 0        # blank rows below the box
+info_box_padding_left = 0          # blank columns left of the box
+info_box_padding_right = 0         # blank columns right of the box
+
+# ---- Popup colour (edit / insert box) ----
+# Pick one name from POPUP_THEMES.  Colours are from the traditional
+# Japanese colour list (Wikipedia: "Traditional colors of Japan").
+popup_theme = "fujimurasaki"
+POPUP_THEMES = {
+    # name:       (background, text,      colour name)
+    "ruri":       ("#1F4788", "#EBF6F7", "瑠璃色 Ruri-iro, lapis lazuli"),
+    "kikyo":      ("#5D3F6A", "#EBF6F7", "桔梗色 Kikyō-iro, bellflower"),
+    "suo":        ("#7E2639", "#EBF6F7", "蘇芳 Su'ō, sappanwood"),
+    "rokusho":    ("#407A52", "#EBF6F7", "緑青 Rokushō, verdigris"),
+    "shinbashi":  ("#006C7F", "#EBF6F7", "新橋色 Shinbashi-iro, teal"),
+    "botan":      ("#A4345D", "#EBF6F7", "牡丹 Bōtan, tree peony"),
+    "fujimurasaki": ("#875F9A", "#EBF6F7", "藤紫 Fujimurasaki, wisteria purple"),
+    "yamabuki":   ("#FFA400", "#192236", "山吹色 Yamabuki-iro, golden yellow"),
+}
+
+# =====================================================================
+#  end of CONFIG
+# =====================================================================
+
+ESC = object()   # a lone Escape key press
+INT = object()   # Ctrl-C
+POPUP_ATTR = curses.A_REVERSE   # fallback when there is no colour; see init_colors()
+
+_NAMED = {
+    "enter": ["\n", "\r", curses.KEY_ENTER], "esc": [ESC], "tab": ["\t"], "space": [" "],
+    "backspace": ["\x7f", "\b", curses.KEY_BACKSPACE], "delete": [curses.KEY_DC],
+    "up": [curses.KEY_UP], "down": [curses.KEY_DOWN],
+    "left": [curses.KEY_LEFT], "right": [curses.KEY_RIGHT],
+    "pageup": [curses.KEY_PPAGE], "pagedown": [curses.KEY_NPAGE],
+    "home": [curses.KEY_HOME], "end": [curses.KEY_END],
+}
+
+
+def _expand(name):
+    n = name.strip()
+    low = n.lower()
+    if low in _NAMED:
+        return list(_NAMED[low])
+    if low.startswith("ctrl-") and len(n) == 6 and n[5].isalpha():
+        return [chr(ord(n[5].upper()) - 64)]
+    if len(n) == 1:
+        return [n]
+    raise ValueError("unknown key name %r in KEYS" % name)
+
+
+def _bind():
+    explicit = {nm for names in KEYS.values()
+                for nm in ([names] if isinstance(names, str) else names)}
+    bound = {}
+    for op, names in KEYS.items():
+        if isinstance(names, str):
+            names = [names]
+        vals = [v for nm in names for v in _expand(nm)]
+        for nm in names:                      # e -> also E, I -> also i ...
+            if len(nm) == 1 and nm.isalpha() and nm.swapcase() not in explicit:
+                vals.append(nm.swapcase())
+        bound[op] = vals
+    return bound
+
+_BOUND = _bind()
+
+
+def is_key(op, k):
+    """True if the pressed key k is bound to operation op."""
+    return k in _BOUND[op]
+
+
+def keys_text(op_or_keys):
+    keys = KEYS[op_or_keys] if isinstance(op_or_keys, str) else op_or_keys
+    if isinstance(keys, str):
+        keys = [keys]
+    return HINT_KEY_SEPARATOR.join(keys)
+
+
+def hint_cells():
+    cells = []
+    for label, ok in HINTS:
+        keys = KEYS[ok] if isinstance(ok, str) else ok
+        if isinstance(keys, str):
+            keys = [keys]
+        cells.append((label, HINT_KEY_SEPARATOR.join(keys) if HINT_SHOW_ALL_KEYS else keys[0]))
+    return cells
+
+
+# ---------------------------------------------------------------- text helpers
+def cw(ch):
+    """Display width of one character."""
+    if unicodedata.combining(ch) or unicodedata.category(ch) in ("Mn", "Me", "Cf"):
+        return 0
+    return 2 if unicodedata.east_asian_width(ch) in ("W", "F") else 1
+
+
+def width(s):
+    return sum(cw(c) for c in s)
+
+
+def clip(s, n):
+    """Longest prefix of s that fits in n terminal cells."""
+    out, used = [], 0
+    for c in s:
+        w = cw(c)
+        if used + w > n:
+            break
+        out.append(c)
+        used += w
+    return "".join(out)
+
+
+def show(s):
+    """Make text safe to draw: tabs -> », control chars -> · (1 cell each)."""
+    out = []
+    for c in s:
+        if c == "\t":
+            out.append("»")
+        elif unicodedata.category(c) in ("Cc", "Cs"):
+            out.append("·")
+        else:
+            out.append(c)
+    return "".join(out)
+
+
+def strip_controls(s):
+    return "".join(c for c in s if c == "\t" or unicodedata.category(c) not in ("Cc", "Cs"))
+
+
+def safe_add(win, y, x, s, attr=0):
+    try:
+        win.addstr(y, x, s, attr)
+    except curses.error:
+        pass
+
+
+def safe_move(win, y, x):
+    try:
+        win.move(y, x)
+    except curses.error:
+        pass
+
+
+def cursor(n):
+    try:
+        curses.curs_set(n)
+    except curses.error:
+        pass
+
+
+# ---------------------------------------------------------------- colours
+def hex_to_256(h):
+    """Nearest xterm-256 colour index for '#RRGGBB'."""
+    r, g, b = (int(h[i:i + 2], 16) for i in (1, 3, 5))
+    lv = [0, 95, 135, 175, 215, 255]
+    near = lambda v: min(range(6), key=lambda i: abs(lv[i] - v))
+    ri, gi, bi = near(r), near(g), near(b)
+    cube = 16 + 36 * ri + 6 * gi + bi
+    dc = (r - lv[ri]) ** 2 + (g - lv[gi]) ** 2 + (b - lv[bi]) ** 2
+    gx = max(0, min(23, round(((r + g + b) / 3 - 8) / 10)))
+    gv = 8 + 10 * gx
+    dg = (r - gv) ** 2 + (g - gv) ** 2 + (b - gv) ** 2
+    return 232 + gx if dg < dc else cube
+
+
+def init_colors():
+    global POPUP_ATTR
+    if not curses.has_colors():
+        return
+    try:
+        curses.start_color()
+        bg, fg, _ = POPUP_THEMES[popup_theme]
+        if curses.COLORS >= 256:
+            curses.init_pair(1, hex_to_256(fg), hex_to_256(bg))
+        else:
+            curses.init_pair(1, curses.COLOR_WHITE, curses.COLOR_BLUE)
+        POPUP_ATTR = curses.color_pair(1)
+    except (curses.error, KeyError):
+        pass
+
+
+# ---------------------------------------------------------------- input
+def read_key(win):
+    """Return a char, a curses KEY_* int, ESC, INT, or ('paste', text)."""
+    win.timeout(-1)
+    try:
+        k = win.get_wch()
+    except KeyboardInterrupt:
+        return INT
+    except curses.error:
+        return None
+    if k != "\x1b":
+        return k
+
+    # ESC: either a lone Esc press or the start of a bracketed paste
+    win.timeout(30)
+    seq = ""
+    try:
+        while len(seq) < 5:
+            c = win.get_wch()
+            if not isinstance(c, str):
+                break
+            seq += c
+            if not "[200~".startswith(seq):
+                break
+    except curses.error:
+        pass
+    finally:
+        win.timeout(-1)
+    if seq != "[200~":
+        return ESC
+
+    end = "\x1b[201~"
+    data = ""
+    win.timeout(1000)
+    try:
+        while not data.endswith(end):
+            c = win.get_wch()
+            if isinstance(c, str):
+                data += c
+    except curses.error:
+        pass
+    finally:
+        win.timeout(-1)
+    if data.endswith(end):
+        data = data[: -len(end)]
+    return ("paste", data)
+
+
+def is_enter(k):
+    return k in ("\n", "\r", curses.KEY_ENTER)
+
+
+def is_backspace(k):
+    return k in ("\x7f", "\b", curses.KEY_BACKSPACE)
+
+
+# ---------------------------------------------------------------- clipboard
+def to_clipboard(text):
+    """Copy to the system clipboard. Returns a short description or None."""
+    data = text.encode("utf-8", "surrogateescape")
+    for cmd in (["wl-copy"], ["xclip", "-selection", "clipboard"], ["xsel", "--clipboard", "--input"]):
+        if shutil.which(cmd[0]):
+            try:
+                subprocess.run(cmd, input=data, timeout=2, check=True,
+                               stdout=subprocess.DEVNULL, stderr=subprocess.DEVNULL)
+                return "clipboard"
+            except (OSError, subprocess.SubprocessError):
+                pass
+    try:  # OSC 52: ask the terminal to set the clipboard
+        sys.stdout.write("\x1b]52;c;%s\x07" % base64.b64encode(data).decode())
+        sys.stdout.flush()
+        return "terminal clipboard"
+    except (OSError, ValueError):
+        return None
+
+
+# ---------------------------------------------------------------- popup editor
+def popup_edit(scr, title, text, row):
+    """Edit one line in a coloured box drawn ON screen row `row` (the line itself).
+    Returns the new text, or None if discarded."""
+    rows, cols = scr.getmaxyx()
+    w = min(cols, max(24, cols - 2 * popup_margin))
+    win = curses.newwin(3, w, max(0, min(row - 1, rows - 3)), max(0, (cols - w) // 2))
+    win.keypad(True)
+    win.bkgd(" ", POPUP_ATTR)
+    hint = " [%s] save   [%s] discard " % (keys_text("save"), keys_text("discard"))
+    inner = max(1, w - 4)
+    buf = list(text)
+    cur = off = 0
+    cursor(1)
+    try:
+        while True:
+            if cur < off:
+                off = cur
+            while width(buf[off:cur]) >= inner:
+                off += 1
+            win.erase()
+            win.box()
+            safe_add(win, 0, 2, clip(title, w - 4), curses.A_BOLD)
+            safe_add(win, 1, 2, clip(show(buf[off:]), inner))
+            safe_add(win, 2, 2, clip(hint, w - 4))
+            safe_move(win, 1, 2 + width(buf[off:cur]))
+            win.refresh()
+
+            k = read_key(win)
+            if is_key("discard", k):
+                return None
+            elif is_key("save", k):
+                return "".join(buf)
+            elif k == curses.KEY_LEFT:
+                cur = max(0, cur - 1)
+            elif k == curses.KEY_RIGHT:
+                cur = min(len(buf), cur + 1)
+            elif k in (curses.KEY_HOME, "\x01"):
+                cur = 0
+            elif k in (curses.KEY_END, "\x05"):
+                cur = len(buf)
+            elif is_backspace(k):
+                if cur > 0:
+                    del buf[cur - 1]
+                    cur -= 1
+            elif k == curses.KEY_DC:
+                if cur < len(buf):
+                    del buf[cur]
+            elif isinstance(k, tuple):  # paste: multi-line text is joined with spaces
+                p = strip_controls(k[1].replace("\r\n", "\n").replace("\r", "\n").replace("\n", " "))
+                buf[cur:cur] = list(p)
+                cur += len(p)
+            elif isinstance(k, str) and len(k) == 1 and (k.isprintable() or k == "\t"):
+                buf.insert(cur, k)
+                cur += 1
+            # everything else (Up/Down, F-keys, Ctrl-C ...) is ignored on purpose
+    finally:
+        cursor(0)
+
+
+# ---------------------------------------------------------------- editor
+class Editor:
+    def __init__(self, path, readonly=False):
+        self.path = path
+        self.readonly = readonly
+        self.msg = ""
+        self.cur = 0
+        self.top = 0
+        self.undo = []
+        self.register = []
+        self.numbers = False      # line numbers: off by default
+        self.body_h = 1
+        self.geo = {"box": False, "body_h": 1, "status": (0, 0, 1)}
+
+        try:
+            with open(path, "rb") as f:
+                raw = f.read()
+        except FileNotFoundError:
+            raw = None
+
+        if raw is None:
+            self.lines, self.eol, self.final_nl, self.orig_empty = [""], "\n", True, True
+            self.msg = "New file"
+        else:
+            text = raw.decode("utf-8", "surrogateescape")
+            crlf = text.count("\r\n")
+            self.eol = "\r\n" if crlf > text.count("\n") - crlf else "\n"
+            self.final_nl = text.endswith("\n") or text == ""
+            self.orig_empty = text == ""
+            body = text[:-1] if text.endswith("\n") else text
+            lines = body.split("\n")
+            if self.eol == "\r\n":
+                lines = [l[:-1] if l.endswith("\r") else l for l in lines]
+            self.lines = lines
+        self.saved = list(self.lines)
+
+    # -- state
+    def modified(self):
+        return self.lines != self.saved
+
+    def push_undo(self):
+        self.undo.append((list(self.lines), self.cur))
+        del self.undo[:-200]
+
+    def deny_if_readonly(self):
+        if self.readonly:
+            self.msg = "Read-only (started with -R)"
+        return self.readonly
+
+    # -- layout
+    def compute_layout(self, rows, cols):
+        pt, pb = max(0, info_box_padding_top), max(0, info_box_padding_bottom)
+        pl, pr = max(0, info_box_padding_left), max(0, info_box_padding_right)
+        cells = hint_cells()
+        iw = cols - pl - pr - 2
+        if iw >= 30 and cells:
+            need = max(len(l) + len(k) + 6 for l, k in cells)   # " label  [key] "
+            n = len(cells)
+            fit = max(1, min(n, (iw + 1) // (need + 1)))
+            nrows = -(-n // fit)
+            ncols = -(-n // nrows)
+            for r in (nrows, nrows + 1):          # prefer a grid with no empty cells
+                if r <= n and n % r == 0 and n // r <= fit:
+                    nrows, ncols = r, n // r
+                    break
+            box_h = 2 * nrows + 3      # top rule, status, rule, (row + rule) per hint row, bottom
+            body_h = rows - (pt + box_h + pb)
+            if body_h >= 3:
+                return {"box": True, "body_h": body_h, "x0": pl, "y0": body_h + pt,
+                        "iw": iw, "ncols": ncols, "nrows": nrows, "status": (0, 0, 1)}
+        return {"box": False, "body_h": max(1, rows - 2), "status": (0, 0, 1)}
+
+    # -- drawing
+    def draw(self, scr):
+        scr.erase()
+        rows, cols = scr.getmaxyx()
+        self.geo = self.compute_layout(rows, cols)
+        h = self.body_h = self.geo["body_h"]
+        if self.cur < self.top:
+            self.top = self.cur
+        if self.cur >= self.top + h:
+            self.top = self.cur - h + 1
+        gw = len(str(len(self.lines)))
+        for i in range(h):
+            n = self.top + i
+            if n >= len(self.lines):
+                safe_add(scr, i, 1, "~")
+                continue
+            gutter = " %*d " % (gw, n + 1) if self.numbers else " "
+            avail = max(1, cols - len(gutter))
+            text = show(self.lines[n].expandtabs(4))
+            if width(text) > avail:
+                text = clip(text, avail - 1) + ">"
+            pad = " " * max(0, avail - width(text))
+            attr = curses.A_REVERSE if n == self.cur else curses.A_NORMAL
+            safe_add(scr, i, 0, gutter + text + pad, attr)
+        self.draw_footer(scr, rows, cols)
+        scr.refresh()
+
+    def draw_footer(self, scr, rows, cols):
+        """Info box: status row (file | VIEW | Line) on top, hint cells at the bottom."""
+        g = self.geo
+        bold = curses.A_BOLD
+        mid = " VIEW "
+        right = " Line: %d/%d " % (self.cur + 1, len(self.lines))
+        cells = hint_cells()
+
+        if not g["box"]:      # small terminal: plain status row + one hint line
+            lw = max(1, cols - 1 - len(mid) - len(right) - 2)
+            g["status"] = (rows - 2, 0, lw)
+            self.draw_status(scr, self.msg or None)
+            safe_add(scr, rows - 2, lw, "\u2502" + mid + "\u2502" + right, bold)
+            x = 1
+            for label, keys in cells:
+                w = len(label) + len(keys) + 3
+                if x + w > cols - 1:
+                    break
+                safe_add(scr, rows - 1, x, label)
+                safe_add(scr, rows - 1, x + len(label) + 1, "[%s]" % keys, bold)
+                x += w + 2
+            return
+
+        x0, y0, iw, ncols, nrows = g["x0"], g["y0"], g["iw"], g["ncols"], g["nrows"]
+        lw = iw - len(mid) - len(right) - 2
+        status_joints = {lw, lw + 1 + len(mid)}
+        base, extra = divmod(iw - (ncols - 1), ncols)
+        widths = [base + (1 if i < extra else 0) for i in range(ncols)]
+        grid_joints, pos = set(), 0
+        for wd in widths[:-1]:
+            pos += wd
+            grid_joints.add(pos)
+            pos += 1
+
+        def rule(l, r, up, down):
+            mid_ = "".join("\u253c" if i in up and i in down else "\u2534" if i in up
+                           else "\u252c" if i in down else "\u2500" for i in range(iw))
+            return l + mid_ + r
+
+        safe_add(scr, y0, x0, rule("\u250c", "\u2510", set(), status_joints))
+        ys = y0 + 1
+        safe_add(scr, ys, x0, "\u2502")
+        g["status"] = (ys, x0 + 1, lw)
+        self.draw_status(scr, self.msg or None)
+        safe_add(scr, ys, x0 + 1 + lw, "\u2502" + mid + "\u2502" + right + "\u2502", bold)
+        safe_add(scr, y0 + 2, x0, rule("\u251c", "\u2524", status_joints, grid_joints))
+        for r in range(nrows):
+            y = y0 + 3 + 2 * r
+            safe_add(scr, y, x0, "\u2502")
+            x = x0 + 1
+            for c in range(ncols):
+                wd = widths[c]
+                idx = r * ncols + c
+                if idx < len(cells):
+                    label, keys = cells[idx]
+                    kt = "[%s]" % keys
+                    safe_add(scr, y, x + 1, clip(label, max(0, wd - len(kt) - 3)))
+                    safe_add(scr, y, x + wd - 1 - len(kt), kt, bold)
+                x += wd
+                safe_add(scr, y, x, "\u2502")
+                x += 1
+            if r < nrows - 1:
+                safe_add(scr, y + 1, x0, rule("\u251c", "\u2524", grid_joints, grid_joints))
+        safe_add(scr, y0 + 2 + 2 * nrows, x0, rule("\u2514", "\u2518", grid_joints, set()))
+
+    def draw_status(self, scr, text=None, attr=None):
+        """Draw the left status cell (file name, or a message / prompt). Returns text x."""
+        y, x, lw = self.geo["status"]
+        if text is None:
+            text = os.path.basename(self.path) + (" [+]" if self.modified() else "") + \
+                (" [RO]" if self.readonly else "")
+            attr = curses.A_BOLD if attr is None else attr
+        elif attr is None:
+            attr = curses.A_NORMAL
+        cell = " " + clip(text, lw - 1)
+        cell += " " * (lw - width(cell))
+        safe_add(scr, y, x, cell, attr)
+        return x + 1
+
+    # -- small prompts in the status cell
+    def confirm(self, scr, text):
+        """Yes only on the 'yes' key; any other key means no."""
+        self.draw_status(scr, "%s  [%s]" % (text, keys_text("yes")), curses.A_BOLD)
+        scr.refresh()
+        return is_key("yes", read_key(scr))
+
+    def prompt(self, scr, prefix):
+        buf = []
+        cursor(1)
+        try:
+            while True:
+                line = prefix + "".join(buf)
+                cx = self.draw_status(scr, line, curses.A_BOLD)
+                safe_move(scr, self.geo["status"][0], cx + width(line))
+                scr.refresh()
+                k = read_key(scr)
+                if k is ESC:
+                    return None
+                if is_enter(k):
+                    return "".join(buf)
+                if is_backspace(k):
+                    if buf:
+                        buf.pop()
+                    else:
+                        return None
+                elif isinstance(k, str) and len(k) == 1 and k.isprintable():
+                    buf.append(k)
+        finally:
+            cursor(0)
+
+    # -- actions
+    def move(self, d):
+        self.cur = max(0, min(len(self.lines) - 1, self.cur + d))
+
+    def edit(self, scr):
+        if self.deny_if_readonly():
+            return
+        old = self.lines[self.cur]
+        new = popup_edit(scr, " Edit line %d " % (self.cur + 1), old, self.cur - self.top)
+        scr.clear()
+        if new is None or new == old:
+            return
+        self.push_undo()
+        self.lines[self.cur] = new
+        self.msg = "Line %d changed" % (self.cur + 1)
+
+    def insert(self, scr):
+        """Insert an empty line below the current one and edit it in place.
+        'discard' removes it again; 'save' keeps it with the typed content."""
+        if self.deny_if_readonly():
+            return
+        old_cur = self.cur
+        pos = old_cur + 1
+        self.push_undo()
+        self.lines.insert(pos, "")
+        self.cur = pos
+        self.draw(scr)
+        new = popup_edit(scr, " New line %d " % (pos + 1), "", self.cur - self.top)
+        scr.clear()
+        if new is None:
+            self.lines.pop(pos)
+            self.undo.pop()
+            self.cur = old_cur
+            return
+        self.lines[pos] = new
+        self.msg = "Line inserted"
+
+    def delete(self, scr):
+        if self.deny_if_readonly():
+            return
+        if not self.confirm(scr, "Delete line %d?" % (self.cur + 1)):
+            return
+        self.push_undo()
+        del self.lines[self.cur]
+        if not self.lines:
+            self.lines = [""]
+        self.cur = min(self.cur, len(self.lines) - 1)
+        self.msg = "Line deleted"
+
+    def copy(self):
+        self.register = [self.lines[self.cur]]
+        where = to_clipboard(self.lines[self.cur])
+        self.msg = "Copied line %d%s" % (self.cur + 1, " (to %s)" % where if where else "")
+
+    def paste(self):
+        if self.deny_if_readonly():
+            return
+        if not self.register:
+            self.msg = "Nothing copied yet (or paste from the terminal)"
+            return
+        self.insert_lines(list(self.register))
+
+    def insert_lines(self, new):
+        self.push_undo()
+        pos = self.cur + 1
+        self.lines[pos:pos] = new
+        self.cur = pos + len(new) - 1
+        self.msg = "%d line(s) inserted" % len(new)
+
+    def paste_text(self, scr, text):
+        if self.deny_if_readonly():
+            return
+        text = text.replace("\r\n", "\n").replace("\r", "\n")
+        new = text.split("\n")
+        if len(new) > 1 and new[-1] == "":
+            new.pop()
+        new = [strip_controls(l) for l in new]
+        if self.confirm(scr, "Paste %d line(s) below line %d?" % (len(new), self.cur + 1)):
+            self.insert_lines(new)
+
+    def do_undo(self):
+        if self.deny_if_readonly():
+            return
+        if not self.undo:
+            self.msg = "Nothing to undo"
+            return
+        self.lines, self.cur = self.undo.pop()
+        self.msg = "Undone"
+
+    def save(self):
+        if self.deny_if_readonly():
+            return False
+        if self.lines == [""]:
+            data = "" if self.orig_empty else self.eol
+        else:
+            data = self.eol.join(self.lines) + (self.eol if self.final_nl else "")
+        target = os.path.realpath(self.path)
+        try:
+            fd, tmp = tempfile.mkstemp(dir=os.path.dirname(target) or ".", prefix=".tlex-")
+            try:
+                with os.fdopen(fd, "wb") as f:
+                    f.write(data.encode("utf-8", "surrogateescape"))
+                    f.flush()
+                    os.fsync(f.fileno())
+                if os.path.exists(target):
+                    shutil.copymode(target, tmp)
+                else:
+                    um = os.umask(0)
+                    os.umask(um)
+                    os.chmod(tmp, 0o666 & ~um)
+                os.replace(tmp, target)
+            except BaseException:
+                try:
+                    os.unlink(tmp)
+                except OSError:
+                    pass
+                raise
+        except OSError as e:
+            self.msg = "Write failed: %s" % e
+            return False
+        self.saved = list(self.lines)
+        self.msg = "Wrote %d lines to %s" % (len(self.lines), self.path)
+        return True
+
+    def command(self, scr):
+        """Run a ':' command. Returns True if the editor should quit."""
+        s = self.prompt(scr, ":")
+        if s is None:
+            return False
+        s = s.strip().lower()
+        if s == "w":
+            self.save()
+        elif s in ("wq", "x"):
+            return self.save()
+        elif s == "q":
+            if self.modified():
+                self.msg = "Unsaved changes: :wq to save, :q! to discard"
+                return False
+            return True
+        elif s == "q!":
+            return True
+        elif s == "$":
+            self.cur = len(self.lines) - 1
+        elif s.isdigit():
+            self.cur = max(0, min(len(self.lines) - 1, int(s) - 1))
+        elif s:
+            self.msg = "Not an editor command: " + s
+        return False
+
+    # -- main loop
+    def run(self, scr):
+        scr.keypad(True)
+        init_colors()
+        cursor(0)
+        sys.stdout.write("\x1b[?2004h")   # bracketed paste on
+        sys.stdout.flush()
+        try:
+            self.loop(scr)
+        finally:
+            sys.stdout.write("\x1b[?2004l")
+            sys.stdout.flush()
+
+    def loop(self, scr):
+        while True:
+            self.draw(scr)
+            k = read_key(scr)
+            self.msg = ""
+            page = max(1, self.body_h - 1)
+
+            if k is INT:
+                self.msg = "Ctrl-C ignored. Use :q to quit"
+            elif isinstance(k, tuple):
+                self.paste_text(scr, k[1])
+            elif is_key("up", k):
+                self.move(-1)
+            elif is_key("down", k):
+                self.move(1)
+            elif is_key("page_up", k):
+                self.move(-page)
+            elif is_key("page_down", k):
+                self.move(page)
+            elif is_key("top", k):
+                self.cur = 0
+            elif is_key("bottom", k):
+                self.cur = len(self.lines) - 1
+            elif is_key("edit", k):
+                self.edit(scr)
+            elif is_key("insert", k):
+                self.insert(scr)
+            elif is_key("copy", k):
+                self.copy()
+            elif is_key("paste", k):
+                self.paste()
+            elif is_key("delete", k):
+                self.delete(scr)
+            elif is_key("undo", k):
+                self.do_undo()
+            elif is_key("numbers", k):
+                self.numbers = not self.numbers
+                self.msg = "Line numbers " + ("on" if self.numbers else "off")
+            elif is_key("command", k):
+                if self.command(scr):
+                    return
+            elif k is ESC or k == curses.KEY_RESIZE or k is None:
+                pass
+            elif isinstance(k, str):
+                self.msg = "View mode is read-only (%s edit, %s insert, %s command)" % (
+                    KEYS["edit"][0], KEYS["insert"][0], KEYS["command"][0])
+
+
+def main():
+    ap = argparse.ArgumentParser(description="tlex - safe line editor / viewer")
+    ap.add_argument("file")
+    ap.add_argument("-R", "--readonly", action="store_true", help="view only, no editing")
+    a = ap.parse_args()
+    if popup_theme not in POPUP_THEMES:
+        sys.exit("tlex: popup_theme %r unknown; choose one of: %s"
+                 % (popup_theme, ", ".join(POPUP_THEMES)))
+    for _, ok in HINTS:
+        if isinstance(ok, str) and ok not in KEYS:
+            sys.exit("tlex: HINTS refers to unknown operation %r" % ok)
+    try:
+        ed = Editor(a.file, a.readonly)
+    except OSError as e:
+        sys.exit("tlex: %s" % e)
+    locale.setlocale(locale.LC_ALL, "")
+    os.environ.setdefault("ESCDELAY", "25")
+    curses.wrapper(ed.run)
+
+
+if __name__ == "__main__":
+    main()

tlex-1.0.0/src/tlex.egg-info/PKG-INFO

@@ -0,0 +1,137 @@
+Metadata-Version: 2.4
+Name: tlex
+Version: 1.0.0
+Summary: A safe line editor and viewer for the terminal.
+License-Expression: MIT
+Requires-Python: >=3.9
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Dynamic: license-file
+
+# tlex
+
+**A safe line editor and viewer for the terminal.**
+
+tlex is built around one idea: you should never change a file by accident.
+Opening a file is read-only viewing. A change only happens when you deliberately
+open **one line** in a small popup, edit it, and confirm with Enter.
+Everything is undoable, and nothing is written until you say so.
+
+It looks like old vim: plain text, no colour clutter, a bar on the current line,
+and `:wq` to save and quit. Pure Python, standard library only.
+
+```
+ alpha
+ beta                                  <- current line (bar)
+ gamma
+ ~
+                                        
+ ┌─────────────────────────────────────────────────────────────┬──────┬───────────┐
+ │ notes.txt [+]                                               │ VIEW │ Line: 2/3 │
+ ├──────────────┬──────────────┬──────────────┬────────────────┴──────┴───────────┤
+ │ edit     [e] │ insert   [i] │ delete   [d] │ copy      [y]  ...                │
+ └──────────────┴──────────────┴──────────────┴───────────────────────────────────┘
+```
+
+## Features
+
+- **Safe by design:** view mode is read-only; unknown keys do nothing.
+- **One line at a time:** edit happens in a popup placed on the line itself.
+- **Insert between lines:** `i` adds a new line below the current one and opens it for editing. Esc removes it again.
+- **Undo** for every change; **delete and paste ask first** (`[y]` = yes, any other key = no).
+- **Copy and paste:** copy a line to the system clipboard, put it back with `p`, or paste from the terminal (multi-line paste is detected as one block and asks before inserting).
+- **Atomic saves:** written to a temp file and renamed, permissions kept. CRLF files and a missing final newline are preserved.
+- **`:q` protects your work:** it refuses to quit with unsaved changes; `:q!` discards on purpose.
+- **Configurable:** keys (several per operation), hint table, padding and popup colour are all set in one block at the top of the file.
+- **Optional line numbers** (off by default), read-only mode, UTF-8 and wide characters.
+
+## Install
+
+### With pipx
+
+```bash
+pipx install git+https://github.com/datatalisman/tlex
+```
+
+### From a clone of the repo
+
+```bash
+git clone https://github.com/datatalisman/tlex
+cd tlex
+./install.sh
+```
+
+### Uninstall
+
+```bash
+./uninstall.sh          # from the repo directory
+# or, if you used pipx directly:
+pipx uninstall tlex
+```
+
+**Requirements:** Python 3 and a terminal on Linux or macOS (it uses `curses`; Windows is not supported).
+For copying to the system clipboard it uses `wl-copy`, `xclip` or `xsel` if available, and falls back to the terminal's OSC 52 clipboard.
+
+## Usage
+
+```bash
+tlex notes.txt        # edit (a missing file starts as a new file)
+tlex -R notes.txt     # view only, no editing possible
+```
+
+### View mode keys
+
+| Key | Action |
+|---|---|
+| `Up` `Down` `PageUp` `PageDown` | Move |
+| `Home` / `g`, `End` / `G` | Top / bottom |
+| `e`, `Enter` | Edit the current line (popup, cursor at the start) |
+| `i` | Insert a new line below, then edit it |
+| `d` | Delete the current line (asks first) |
+| `y`, `c` | Copy the current line |
+| `p` | Put the copied line below the current one |
+| `u` | Undo |
+| `n` | Toggle line numbers |
+| `:` | Command line |
+
+### Edit / insert popup
+
+| Key | Action |
+|---|---|
+| `Enter` | Save the line |
+| `Esc` | Discard (for `i`, the new line disappears) |
+| `Left` `Right` `Home` `End` | Move inside the line |
+| `Backspace` `Delete` | Erase |
+| terminal paste | Insert at the cursor (multi-line text is joined with spaces) |
+
+Up and Down are ignored in the popup on purpose, so you cannot leave the line by accident.
+
+### Commands (press `:`)
+
+| Command | Action |
+|---|---|
+| `:w` | Write |
+| `:wq` | Write and quit |
+| `:q` | Quit (refuses if there are unsaved changes) |
+| `:q!` | Quit and discard changes |
+| `:N` | Go to line N |
+
+`Esc` followed by `:` works as in vim.
+
+## Configuration
+
+Everything is in the **CONFIG** block at the top of `tlex.py`:
+
+- **`KEYS`:** operation → list of keys. Add as many keys as you like per operation, for example `"copy": ["y", "c"]`. Keys are characters (`"e"`, `":"`) or names (`Enter`, `Esc`, `Tab`, `Space`, `Backspace`, `Delete`, `Up`, `Down`, `Left`, `Right`, `PageUp`, `PageDown`, `Home`, `End`, `Ctrl-S`).
+- **`HINTS`:** the cells of the hint table at the bottom. They are generated from `KEYS`, so they update when you change a key. `HINT_SHOW_ALL_KEYS = True` shows every key of an operation (`[y/c]`) instead of the first one.
+- **`info_box_padding_top`, `_bottom`, `_left`, `_right`:** blank space around the info box.
+- **`popup_theme`:** colour of the popup, chosen from `POPUP_THEMES` (traditional Japanese colours): `ruri`, `kikyo`, `suo`, `rokusho`, `shinbashi`, `botan`, `fujimurasaki`, `yamabuki`. Add your own as `name: (background hex, text hex, description)`.
+
+After editing the config, reinstall (run `./install.sh` again) so the installed copy picks up the change.
+
+## Safety notes
+
+- tlex never modifies the file until you run `:w` or `:wq`.
+- Writes go to a temporary file in the same directory and are renamed over the original, so a crash cannot leave a half-written file.
+- The undo history lives only while the editor is open.
+- Files with bytes that are not valid UTF-8 are kept byte for byte; those bytes are shown as `·`.

tlex-1.0.0/src/tlex.egg-info/SOURCES.txt

@@ -0,0 +1,10 @@
+LICENSE
+README.md
+pyproject.toml
+src/app/__init__.py
+src/app/main.py
+src/tlex.egg-info/PKG-INFO
+src/tlex.egg-info/SOURCES.txt
+src/tlex.egg-info/dependency_links.txt
+src/tlex.egg-info/entry_points.txt
+src/tlex.egg-info/top_level.txt

tlex-1.0.0/src/tlex.egg-info/dependency_links.txt

@@ -0,0 +1 @@
+

tlex-1.0.0/src/tlex.egg-info/entry_points.txt

@@ -0,0 +1,2 @@
+[console_scripts]
+tlex = app.main:main

tlex-1.0.0/src/tlex.egg-info/top_level.txt

@@ -0,0 +1 @@
+app