bytesim 0.1.0__py3-none-any.whl

bytesim/tui/cables.py

@@ -0,0 +1,58 @@
+"""Where cables are drawn: orthogonal paths between ports, and the line glyphs."""
+from __future__ import annotations
+
+from ..constants import BOX_H
+from ..model import Device, Link, Network
+
+N, E, S, W = 1, 2, 4, 8
+
+LINE = {
+    0: " ", N: "│", S: "│", N | S: "│", E: "─", W: "─", E | W: "─",
+    N | E: "└", N | W: "┘", S | E: "┌", S | W: "┐",
+    N | S | E: "├", N | S | W: "┤", E | W | S: "┬", E | W | N: "┴",
+    N | E | S | W: "┼",
+}
+
+LINE2 = {m: c.translate(str.maketrans("│─└┘┌┐├┤┬┴┼", "║═╚╝╔╗╠╣╦╩╬")) for m, c in LINE.items()}
+
+LINE_HEAVY = {m: c.translate(str.maketrans("│─└┘┌┐├┤┬┴┼", "┃━┗┛┏┓┣┫┳┻╋")) for m, c in LINE.items()}
+LINE_DASH = {m: c.translate(str.maketrans("│─", "┆┄")) for m, c in LINE.items()}   # STP-blocked
+
+
+def dirbit(dx: int, dy: int) -> int:
+    return {(0, -1): N, (1, 0): E, (0, 1): S, (-1, 0): W}[(dx, dy)]
+
+
+def _polyline(corners: list[tuple[int, int]]) -> list[tuple[int, int]]:
+    pts = [corners[0]]
+    for x2, y2 in corners[1:]:
+        x, y = pts[-1]
+        while (x, y) != (x2, y2):
+            x += (x2 > x) - (x2 < x)
+            y += (y2 > y) - (y2 < y)
+            pts.append((x, y))
+    return pts
+
+def _zpath(s: tuple[int, int], e: tuple[int, int], idx: int) -> list[tuple[int, int]]:
+    (sx, sy), (ex, ey) = s, e
+    gap = ey - sy
+    mid = sy + 1 + idx % (gap - 1) if gap >= 2 else sy
+    return _polyline([(sx, sy), (sx, mid), (ex, mid), (ex, ey)])
+
+def _bus_slot(net: Network, dev: Device) -> int:
+    row = sorted(d.x for d in net.devices.values() if d.y == dev.y)
+    return row.index(dev.x)
+
+def route(net: Network, link: Link, idx: int) -> list[tuple[int, int]]:
+    """Cells a cable occupies, ordered from link.a to link.b."""
+    A, B = net.devices[link.a], net.devices[link.b]
+    ax, bx = A.port_x(link.pa), B.port_x(link.pb)
+    # Cables leaving the same upper device share a horizontal "bus" row;
+    # neighbouring devices use different rows so their buses don't merge.
+    if B.y >= A.y + BOX_H + 1:      # B below A
+        return _zpath((ax, A.y + BOX_H), (bx, B.y - 1), _bus_slot(net, A))
+    if A.y >= B.y + BOX_H + 1:      # B above A
+        return _zpath((bx, B.y + BOX_H), (ax, A.y - 1), _bus_slot(net, B))[::-1]
+    # Overlapping rows: loop underneath both boxes.
+    y = max(A.y, B.y) + BOX_H + 1 + idx % 2
+    return _polyline([(ax, A.y + BOX_H), (ax, y), (bx, y), (bx, B.y + BOX_H)])

bytesim/tui/canvas.py

@@ -0,0 +1,489 @@
+"""The network canvas: draws devices, cables, frames and packets; mouse and keys."""
+from __future__ import annotations
+
+from collections import Counter
+from dataclasses import dataclass
+from typing import Callable
+
+from rich.text import Text
+from textual import events
+from textual.binding import Binding
+from textual.widget import Widget
+
+from ..constants import BOX_H
+from ..model import Device, Network, fmt
+from .cables import LINE, LINE2, LINE_DASH, LINE_HEAVY, N, S, dirbit, route
+from .theme import HA_COLOR, ROLE_COLOR, group_color
+
+@dataclass
+class Packet:
+    cells: list[tuple[int, int]]
+    color: str
+    on_done: Callable[[], None] | None = None
+    pos: int = 0
+
+
+TRAIL = 4
+
+
+class NetCanvas(Widget, can_focus=True):
+    BINDINGS = [
+        Binding("up", "move(0,-1)", "Move", show=False),
+        Binding("down", "move(0,1)", "Move", show=False),
+        Binding("left", "move(-1,0)", "Move", show=False),
+        Binding("right", "move(1,0)", "Move", show=False),
+        Binding("shift+up", "move(0,-4)", show=False),
+        Binding("shift+down", "move(0,4)", show=False),
+        Binding("shift+left", "move(-4,0)", show=False),
+        Binding("shift+right", "move(4,0)", show=False),
+        Binding("tab", "cycle(1)", "Next dev"),
+        Binding("shift+tab", "cycle(-1)", "Prev dev", show=False),
+        Binding("a", "arrange", "Auto-arrange"),
+        Binding("u", "undo", "Undo"),
+        Binding("U", "redo", "Redo", show=False),
+        Binding("v", "toggle_addr", "Addresses"),
+        Binding("x,delete", "delete", "Delete"),
+        Binding("h", "pan(-4,0)", "Pan hjkl", show=False),
+        Binding("j", "pan(0,2)", show=False),
+        Binding("k", "pan(0,-2)", show=False),
+        Binding("l", "pan(4,0)", show=False),
+        Binding("enter,colon,slash,i", "app.focus_cmd", "Command"),
+        Binding("escape", "deselect", show=False),
+    ]
+
+    def __init__(self, **kw) -> None:
+        super().__init__(**kw)
+        self.selected: str | None = None
+        self.selected_group: str | None = None
+        self.show_addr = True
+        self.pan = (0, 0)
+        self.packets: list[Packet] = []
+        self.hot_links: Counter[int] = Counter()
+        self.flash: dict[str, list] = {}   # device -> [colour, ticks left]
+        self._timer = None
+        self._drag: tuple | None = None
+        self.frame = 0                      # animation clock (storms crawl along their loop)
+
+    def reset(self) -> None:
+        """Forget selection and anything in flight (the network was replaced)."""
+        self.selected = self.selected_group = None
+        self.packets.clear()
+        self.flash.clear()
+        self.hot_links.clear()
+        self.pan = (0, 0)
+
+    @property
+    def busy(self) -> bool:
+        """True while packets are animating."""
+        return bool(self.packets)
+
+    @property
+    def net(self) -> Network:
+        return self.app.net  # type: ignore[attr-defined]
+
+    # ---- selection / movement -----------------------------------------
+    def select(self, dev_id: str | None) -> None:
+        self.selected = dev_id
+        self.selected_group = None
+        if dev_id:
+            d = self.net.devices[dev_id]
+            self.scroll_into_view(d.x, d.y, d.x + d.width - 1, d.y + BOX_H - 1)
+        self.app.refresh_sidebar()  # type: ignore[attr-defined]
+        self.refresh()
+
+    def select_group(self, name: str) -> None:
+        self.selected = None
+        self.selected_group = name
+        self.scroll_into_view(*self.net.group_bounds(name))
+        self.app.refresh_sidebar()  # type: ignore[attr-defined]
+        self.refresh()
+
+    def scroll_into_view(self, x0: int, y0: int, x1: int, y1: int) -> None:
+        ox, oy = self.pan
+        w, h = self.size.width or 80, self.size.height or 24
+        if x0 < ox:
+            ox = x0 - 2
+        elif x1 >= ox + w:
+            ox = x1 - w + 3
+        if y0 < oy:
+            oy = y0 - 1
+        elif y1 >= oy + h:
+            oy = y1 - h + 3
+        self.pan = (ox, oy)
+
+    def _moving(self) -> list[Device]:
+        if self.selected_group:
+            return [self.net.devices[d] for d in self.net.devices_in(self.selected_group)]
+        return [self.net.devices[self.selected]] if self.selected else []
+
+    def _shift(self, devs: list[Device], dx: int, dy: int, what: str = "") -> bool:
+        """Move devices together without letting any go off the top/left edge."""
+        dx = max(dx, -min(d.x for d in devs))
+        dy = max(dy, -min(d.y for d in devs))
+        if dx or dy:
+            self.app.before_move(what or " ".join(d.id for d in devs))  # type: ignore[attr-defined]
+        for d in devs:
+            d.x, d.y = d.x + dx, d.y + dy
+        if dx or dy:
+            self.app.manual_moved()  # type: ignore[attr-defined]
+        return bool(dx or dy)
+
+    def action_move(self, dx: int, dy: int) -> None:
+        devs = self._moving()
+        if not devs:
+            self.app.log_msg("[dim]select a device or group first (tab, click, or type its name)[/]")  # type: ignore[attr-defined]
+            return
+        self._shift(devs, dx, dy, self.selected_group or self.selected or "")
+        if self.selected_group:
+            self.scroll_into_view(*self.net.group_bounds(self.selected_group))
+        else:
+            d = devs[0]
+            self.scroll_into_view(d.x, d.y, d.x + d.width - 1, d.y + BOX_H - 1)
+        self.app.refresh_sidebar()  # type: ignore[attr-defined]
+        self.refresh()
+
+    def action_cycle(self, step: int) -> None:
+        devs = [d.id for d in self.net.sorted_devices()]
+        if not devs:
+            return
+        i = devs.index(self.selected) + step if self.selected in devs else (0 if step > 0 else -1)
+        self.select(devs[i % len(devs)])
+
+    def action_deselect(self) -> None:
+        self.select(None)
+
+    def action_arrange(self) -> None:
+        self.app.run_command("auto")  # type: ignore[attr-defined]   (so it can be undone)
+
+    def action_delete(self) -> None:
+        if self.selected_group:
+            self.app.run_command(f"ungroup {self.selected_group}")  # type: ignore[attr-defined]
+        elif self.selected:
+            self.app.run_command(f"del {self.selected}")  # type: ignore[attr-defined]
+
+    def action_undo(self) -> None:
+        self.app.run_command("undo")  # type: ignore[attr-defined]
+
+    def action_redo(self) -> None:
+        self.app.run_command("redo")  # type: ignore[attr-defined]
+
+    def action_toggle_addr(self) -> None:
+        self.show_addr = not self.show_addr
+        self.refresh()
+
+    def action_pan(self, dx: int, dy: int) -> None:
+        self.pan = (self.pan[0] + dx, self.pan[1] + dy)
+        self.refresh()
+
+    # ---- mouse ---------------------------------------------------------
+    def _hit(self, wx: int, wy: int) -> Device | None:
+        for d in reversed(self._draw_order()):
+            if d.contains(wx, wy):
+                return d
+        return None
+
+    def _hit_group(self, wx: int, wy: int) -> str | None:
+        """A group is hit by clicking its frame (border or label); inner frames win."""
+        for g in sorted(self.net.groups, key=lambda g: -len(self.net.chain(g))):
+            x0, y0, x1, y1 = self.net.group_bounds(g)
+            on_x = wx in (x0, x1) and y0 <= wy <= y1
+            on_y = wy in (y0, y1) and x0 <= wx <= x1
+            if on_x or on_y:
+                return g
+        return None
+
+    def on_mouse_down(self, event: events.MouseDown) -> None:
+        off = event.get_content_offset(self)
+        if off is None:
+            return
+        self.focus()
+        wx, wy = off.x + self.pan[0], off.y + self.pan[1]
+        hit = self._hit(wx, wy)
+        if hit:
+            self.select(hit.id)
+            self._drag = ("dev", hit.id, wx, wy)
+        elif g := self._hit_group(wx, wy):
+            self.select_group(g)
+            self._drag = ("group", g, wx, wy)
+        else:
+            self._drag = ("pan", off.x, off.y, *self.pan)
+        self.capture_mouse()
+
+    def on_mouse_move(self, event: events.MouseMove) -> None:
+        if not self._drag:
+            return
+        off = event.get_content_offset_capture(self)
+        if self._drag[0] in ("dev", "group"):
+            kind, name, lx, ly = self._drag
+            if kind == "dev":
+                devs = [self.net.devices[name]] if name in self.net.devices else []
+            else:
+                devs = [self.net.devices[d] for d in self.net.devices_in(name)]
+            if not devs:
+                return
+            wx, wy = off.x + self.pan[0], off.y + self.pan[1]
+            if self._shift(devs, wx - lx, wy - ly, name):
+                self._drag = (kind, name, wx, wy)
+                self.refresh()
+        else:
+            _, sx, sy, ox, oy = self._drag
+            self.pan = (ox - (off.x - sx), oy - (off.y - sy))
+            self.refresh()
+
+    def on_mouse_up(self, event: events.MouseUp) -> None:
+        if self._drag:
+            self._drag = None
+            self.release_mouse()
+            self.app.refresh_sidebar()  # type: ignore[attr-defined]
+
+    def on_mouse_scroll_down(self, event: events.MouseScrollDown) -> None:
+        self.action_pan(*((4, 0) if event.shift else (0, 2)))
+
+    def on_mouse_scroll_up(self, event: events.MouseScrollUp) -> None:
+        self.action_pan(*((-4, 0) if event.shift else (0, -2)))
+
+    # ---- packets -------------------------------------------------------
+    def send_packet(self, cells: list[tuple[int, int]], color: str,
+                    on_done: Callable[[], None] | None = None) -> None:
+        self.packets.append(Packet(cells, color, on_done))
+        if self._timer is None:
+            self._timer = self.set_interval(1 / 45, self._tick)
+
+    def heat(self, links) -> None:
+        self.hot_links.update(links)
+
+    def cool(self, links) -> None:
+        self.hot_links.subtract(links)
+        self.hot_links += Counter()   # drop zero counts
+        self.refresh()
+
+    def flash_device(self, dev_id: str, color: str, ticks: int = 30) -> None:
+        self.flash[dev_id] = [color, ticks]
+        self.animate()
+
+    def animate(self) -> None:
+        """Make sure the animation clock is running (it stops itself when idle)."""
+        if self._timer is None:
+            self._timer = self.set_interval(1 / 45, self._tick)
+
+    def _tick(self) -> None:
+        for pk in list(self.packets):
+            pk.pos += 1
+            if pk.pos - TRAIL >= len(pk.cells):
+                self.packets.remove(pk)
+                if pk.on_done:
+                    pk.on_done()
+        for dev_id in list(self.flash):
+            self.flash[dev_id][1] -= 1
+            if self.flash[dev_id][1] <= 0:
+                del self.flash[dev_id]
+        self.frame += 1
+        if not self.packets and not self.flash and not self.net.storming and self._timer is not None:
+            self._timer.stop()
+            self._timer = None
+        self.refresh()
+
+    # ---- rendering -----------------------------------------------------
+    def _draw_order(self) -> list[Device]:
+        return sorted(self.net.devices.values(), key=lambda d: d.id == self.selected)
+
+    def render(self) -> Text:
+        w, h = self.size.width, self.size.height
+        ox, oy = self.pan
+        chars = [[" "] * w for _ in range(h)]
+        styles = [[""] * w for _ in range(h)]
+
+        def put(x: int, y: int, ch: str, st: str) -> None:
+            sx, sy = x - ox, y - oy
+            if 0 <= sx < w and 0 <= sy < h:
+                chars[sy][sx] = ch
+                styles[sy][sx] = st
+
+        net = self.net
+        masks: dict[tuple[int, int], int] = {}
+        cell_style: dict[tuple[int, int], str] = {}
+        sides: dict[tuple[str, int], str] = {}
+        hot = set(self.hot_links)
+        if self.selected:
+            hot |= {i for i, l in enumerate(net.links) if l.touches(self.selected)}
+        if self.selected_group:
+            members = set(net.devices_in(self.selected_group))
+            hot |= {i for i, l in enumerate(net.links) if l.a in members or l.b in members}
+
+        kinds: dict[tuple[int, int], set[str]] = {}
+        broken: list[tuple[int, int]] = []
+        crawl: list[list[tuple[int, int]]] = []          # storm loops: dots run along them
+        looping = net.loop_links() if net.storming else set()
+        for i, l in enumerate(net.links):
+            pts = route(net, l, i)
+            alive = l.up and net.devices[l.a].up and net.devices[l.b].up
+            blocked = (l.a, l.pa) in net.stp_blocked or (l.b, l.pb) in net.stp_blocked
+            storm = l.a in net.storming or l.b in net.storming
+            if storm and i in looping:
+                crawl.append(pts)
+            st = ("red" if not alive or storm else "grey35" if blocked
+                  else "bold yellow" if i in hot else ROLE_COLOR[l.role])
+            kind = "control" if l.control else "blocked" if blocked else l.role
+            for pt in pts:
+                kinds.setdefault(pt, set()).add(kind)
+            if not l.up:
+                broken.append(pts[len(pts) // 2])
+            for (x1, y1), (x2, y2) in zip(pts, pts[1:]):
+                masks[(x1, y1)] = masks.get((x1, y1), 0) | dirbit(x2 - x1, y2 - y1)
+                masks[(x2, y2)] = masks.get((x2, y2), 0) | dirbit(x1 - x2, y1 - y2)
+            for dev_id, port, pt in ((l.a, l.pa, pts[0]), (l.b, l.pb, pts[-1])):
+                below = pt[1] > net.devices[dev_id].y
+                masks[pt] = masks.get(pt, 0) | (N if below else S)
+                sides[(dev_id, port)] = "bottom" if below else "top"
+            for pt in pts:
+                if i in hot or pt not in cell_style:
+                    cell_style[pt] = st
+        frames = []
+        for g in sorted(net.groups, key=lambda g: len(net.chain(g))):   # outer frames first
+            sel = g == self.selected_group
+            label = f" {g} "
+            st = group_color(g)
+            if g in net.clusters and not self.app.graph:  # type: ignore[attr-defined]
+                ha = net.ha_state(g)
+                label = f" {g} · HA {ha['level']} " if ha["level"] != "ok" else f" {g} · HA "
+                if ha["level"] != "ok":
+                    st = HA_COLOR[ha["level"]]
+            st = "bold yellow" if sel else st
+            x0, y0, x1, y1 = net.group_bounds(g)
+            frames.append((g, st, x0, y0, x1, label))
+            hz, vt = ("━", "┃") if sel else ("┄", "┆")
+            for x in range(x0 + 1, x1):
+                put(x, y0, hz, st)
+                put(x, y1, hz, st)
+            for y in range(y0 + 1, y1):
+                put(x0, y, vt, st)
+                put(x1, y, vt, st)
+            for x, y, ch in ((x0, y0, "╭"), (x1, y0, "╮"), (x0, y1, "╰"), (x1, y1, "╯")):
+                put(x, y, ch, st)
+
+        for (x, y), m in masks.items():
+            k = kinds.get((x, y), {"data"})
+            table = (LINE2 if k == {"control"} else LINE_HEAVY if k == {"fabric"}
+                     else LINE_DASH if k == {"blocked"} else LINE)
+            put(x, y, table[m], cell_style[(x, y)])
+        for x, y in broken:
+            put(x, y, "✕", "bold red")
+        for pts in crawl:
+            for k, (x, y) in enumerate(pts):
+                if (k - self.frame // 2) % 4 == 0:
+                    put(x, y, "•", "bold bright_red")
+
+        # Group labels sit on the top edge, in the first gap no cable passes through.
+        for g, st, x0, y0, x1, label in frames:
+            starts = range(x0 + 2, max(x0 + 3, x1 - len(label)))
+            lx = next((sx for sx in starts
+                       if not any((sx + k, y0) in masks for k in range(len(label)))), x0 + 2)
+            for k, ch in enumerate(label):
+                if (lx + k, y0) not in masks:
+                    put(lx + k, y0, ch, f"bold reverse {st}" if 0 < k < len(label) - 1 else st)
+
+        for d in self._draw_order():
+            self._draw_device(d, put, sides, d.id == self.selected, self.flash.get(d.id))
+
+        if self.show_addr:
+            # Labels wider than their box drop to a lower line instead of colliding.
+            ends: dict[tuple[int, int], int] = {}
+            for d in sorted(net.devices.values(), key=lambda d: d.x):
+                text, st, y = self._addr_label(d)
+                if not text:
+                    continue
+                step = 1 if d.kind == "c" else -1
+
+                def blocked(lv: int, dx: int) -> bool:
+                    return (ends.get((y, lv), -10**6) >= d.x + dx
+                            or any((d.x + dx + k, y + lv * step) in masks for k in range(len(text))))
+
+                level, dx = next(((lv, dx) for dx in range(d.width) for lv in range(3)
+                                  if not blocked(lv, dx)), (0, 0))
+                ends[(y, level)] = d.x + dx + len(text)
+                y += level * step
+                for k, ch in enumerate(text):
+                    if (d.x + dx + k, y) not in masks:
+                        put(d.x + dx + k, y, ch, st)
+
+        for pk in self.packets:
+            for k in range(TRAIL):
+                idx = pk.pos - k
+                if 0 <= idx < len(pk.cells):
+                    x, y = pk.cells[idx]
+                    put(x, y, "●" if k == 0 else "•", f"bold {pk.color}" if k == 0 else pk.color)
+
+        text = Text(no_wrap=True, overflow="crop")
+        for row in range(h):
+            start = 0
+            for col in range(1, w + 1):
+                if col == w or styles[row][col] != styles[row][start]:
+                    text.append("".join(chars[row][start:col]), styles[row][start] or None)
+                    start = col
+            if row < h - 1:
+                text.append("\n")
+        return text
+
+    def _addr_label(self, d: Device) -> tuple[str, str, int]:
+        """Short address caption drawn under computers and above gateways."""
+        net = self.net
+        if d.kind == "g":
+            return "☁ internet", "magenta", d.y - 1
+        if d.kind != "c" or self.app.graph:  # type: ignore[attr-defined]
+            return "", "", 0
+        y = d.y + BOX_H
+        for g in net.chain(d.id):                 # step below any frame edges under the box
+            bottom = net.group_bounds(g)[3]
+            if y <= bottom <= d.y + BOX_H + 3:
+                y = bottom + 1
+        addrs = net.addressed(d.id)
+        if not addrs:
+            cabled = any(net.link_index(d.id, p) is not None for p in range(1, d.nports + 1))
+            return ("no addr", "red", y) if cabled else ("", "", 0)
+        _, ifc = addrs[0]
+        st = {"adhoc": "yellow", "static": "cyan"}.get(ifc.via, "grey70")
+        return fmt(ifc.addr) + (f"+{len(addrs) - 1}" if len(addrs) > 1 else ""), st, y
+
+    def _draw_device(self, d: Device, put, sides: dict, selected: bool, flash=None) -> None:
+        if selected:
+            tl, tr, bl, br, hz, vt, dn, up = "╔╗╚╝═║╤╧"
+            bst = "bold yellow"
+        else:
+            tl, tr, bl, br, hz, vt, dn, up = "┌┐└┘─│┬┴"
+            bst = d.color
+        if not d.up:
+            bst = "red"
+        elif d.id in self.net.storming:        # pulse while drowning in a storm
+            bst = "bold bright_red" if (self.frame // 12) % 2 else "red"
+        if flash and flash[1] % 10 >= 3:      # blink on arrival
+            tl, tr, bl, br, hz, vt, dn, up = "┏┓┗┛━┃┳┻"
+            bst = f"bold {flash[0]}"
+        x, y, w = d.x, d.y, d.width
+        rows = [tl + hz * (w - 2) + tr, None, None, bl + hz * (w - 2) + br]
+        for i, ch in enumerate(rows[0]):
+            put(x + i, y, ch, bst)
+        for i, ch in enumerate(rows[3]):
+            put(x + i, y + 3, ch, bst)
+        for r in (1, 2):
+            put(x, y + r, vt, bst)
+            put(x + w - 1, y + r, vt, bst)
+            for i in range(1, w - 1):
+                put(x + i, y + r, " ", "")
+        label = (d.id if d.up else d.id + "✕").center(w - 2)
+        lst = f"bold reverse {d.color}" if selected else f"bold {d.color}"
+        if not d.up:
+            lst = "bold red strike"
+        lpad = len(label) - len(label.lstrip())
+        for i, ch in enumerate(label):
+            put(x + 1 + i, y + 1, ch, lst if lpad - 1 <= i <= lpad + len(d.id) else "")
+        for p in range(1, d.nports + 1):
+            px = d.port_x(p)
+            side = sides.get((d.id, p))
+            if side and (d.id, p) in self.net.stp_blocked:
+                put(px, y + 2, "⊘", "bold yellow")        # held blocking by STP
+                put(px, y + 3 if side == "bottom" else y, dn if side == "bottom" else up, bst)
+            elif side:
+                put(px, y + 2, "●", f"bold {d.color}")
+                put(px, y + 3 if side == "bottom" else y, dn if side == "bottom" else up, bst)
+            else:
+                put(px, y + 2, "○", "grey42")

bytesim/tui/command_input.py

@@ -0,0 +1,29 @@
+"""The command line, with history on up/down."""
+from __future__ import annotations
+
+from textual.binding import Binding
+from textual.widgets import Input
+
+class CommandInput(Input):
+    BINDINGS = [
+        Binding("escape", "app.focus_canvas", "Canvas", show=False),
+        Binding("up", "history(-1)", show=False),
+        Binding("down", "history(1)", show=False),
+    ]
+
+    def __init__(self, **kw) -> None:
+        super().__init__(**kw)
+        self.history: list[str] = []
+        self.hpos = 0
+
+    def remember(self, line: str) -> None:
+        if line and (not self.history or self.history[-1] != line):
+            self.history.append(line)
+        self.hpos = len(self.history)
+
+    def action_history(self, step: int) -> None:
+        if not self.history:
+            return
+        self.hpos = max(0, min(len(self.history), self.hpos + step))
+        self.value = self.history[self.hpos] if self.hpos < len(self.history) else ""
+        self.cursor_position = len(self.value)

bytesim/tui/commands/__init__.py

@@ -0,0 +1 @@
+"""Console commands, grouped by topic. Each handler is registered with @command."""