agentirc-cli 6.2.0__tar.gz → 6.2.1__tar.gz

{agentirc_cli-6.2.0 → agentirc_cli-6.2.1}/CHANGELOG.md

@@ -4,6 +4,22 @@ All notable changes to this project will be documented in this file.
 
 Format follows [Keep a Changelog](https://keepachangelog.com/).
 
+## [6.2.1] - 2026-04-13
+
+
+### Added
+
+- Copy-paste guidance in help screen (Shift+drag bypasses TUI mouse capture in modern terminals)
+
+
+### Fixed
+
+- #227: Tab now cycles channels (added priority=True to override Textual Screen focus-cycling)
+- #226: Alt+Left/Right jump by word in chat input; Alt+Backspace deletes previous word
+- #225: `culture channel message` interprets literal \n, \t, and \\ (escape-an-escape); observer splits multi-line text into one PRIVMSG per line and rejects all-empty-after-interpretation input with a non-zero exit
+- #224: Exiting overview now reloads the current channel history (was empty)
+- Help screen now opens on F1 (Ctrl+H stays as secondary — most terminals forward it as Backspace)
+
 ## [6.2.0] - 2026-04-12
 
 

{agentirc_cli-6.2.0 → agentirc_cli-6.2.1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: agentirc-cli
-Version: 6.2.0
+Version: 6.2.1
 Summary: Legacy alias for culture — install culture instead
 Project-URL: Homepage, https://github.com/OriNachum/culture
 Author: Ori Nachum

{agentirc_cli-6.2.0 → agentirc_cli-6.2.1}/culture/cli/channel.py

@@ -208,6 +208,40 @@ def _cmd_read(args: argparse.Namespace) -> None:
         print(msg)
 
 
+def _interpret_escapes(text: str) -> str:
+    """Convert shell-literal ``\\n`` / ``\\t`` / ``\\\\`` sequences to real chars.
+
+    Walks the string left-to-right so a preceding backslash escapes the next
+    character — ``\\\\n`` stays as the two chars ``\\`` + ``n``, while ``\\n``
+    becomes a real newline. Supported escapes: ``\\n`` → newline, ``\\t`` →
+    tab, ``\\\\`` → single backslash. Any other ``\\x`` pair is passed through
+    unchanged so we don't surprise users with ``\\x..`` / ``\\u....`` style
+    interpretation that ``codecs.decode(..., "unicode_escape")`` would do.
+    """
+    out: list[str] = []
+    i = 0
+    n = len(text)
+    while i < n:
+        ch = text[i]
+        if ch == "\\" and i + 1 < n:
+            nxt = text[i + 1]
+            if nxt == "n":
+                out.append("\n")
+                i += 2
+                continue
+            if nxt == "t":
+                out.append("\t")
+                i += 2
+                continue
+            if nxt == "\\":
+                out.append("\\")
+                i += 2
+                continue
+        out.append(ch)
+        i += 1
+    return "".join(out)
+
+
 def _cmd_message(args: argparse.Namespace) -> None:
     if not args.target.strip():
         print("Error: channel name cannot be empty", file=sys.stderr)
@@ -216,14 +250,23 @@ def _cmd_message(args: argparse.Namespace) -> None:
         print("Error: message text cannot be empty", file=sys.stderr)
         sys.exit(1)
     target = args.target if args.target.startswith("#") else f"#{args.target}"
+    text = _interpret_escapes(args.text)
+
+    # After escape interpretation, reject input that has no non-empty line —
+    # otherwise we'd print "Sent to ..." while nothing actually goes out.
+    if not any(line.strip() for line in text.split("\n")):
+        print(
+            "Error: message text has no non-empty line after escape interpretation", file=sys.stderr
+        )
+        sys.exit(1)
 
-    resp = _try_ipc("irc_send", channel=target, message=args.text)
+    resp = _try_ipc("irc_send", channel=target, message=text)
     if resp and resp.get("ok"):
         print(f"Sent to {target}")
         return
 
     observer = get_observer(args.config)
-    asyncio.run(observer.send_message(target, args.text))
+    asyncio.run(observer.send_message(target, text))
     print(f"Sent to {target}")
 
 

{agentirc_cli-6.2.0 → agentirc_cli-6.2.1}/culture/console/app.py

@@ -35,11 +35,15 @@ class ConsoleApp(App):
     BINDINGS = [
         Binding("ctrl+o", "show_overview", "Overview", show=True),
         Binding("ctrl+s", "show_status", "Status", show=True),
-        Binding("ctrl+h", "show_help", "Help", show=True),
+        Binding("f1", "show_help", "Help", show=True),
+        # Most terminals send 0x08 (backspace) for Ctrl+H, so this secondary
+        # bind only fires under terminals with modifyOtherKeys enabled.
+        Binding("ctrl+h", "show_help", "Help", show=False),
         Binding("escape", "back_to_chat", "Chat", show=True),
         Binding("ctrl+q", "quit_app", "Quit", show=True),
-        Binding("tab", "next_channel", "Next channel", show=False),
-        Binding("shift+tab", "prev_channel", "Prev channel", show=False),
+        # priority=True so Tab wins against Screen's default focus-cycling.
+        Binding("tab", "next_channel", "Next channel", show=False, priority=True),
+        Binding("shift+tab", "prev_channel", "Prev channel", show=False, priority=True),
     ]
 
     DEFAULT_CSS = """
@@ -413,11 +417,19 @@ class ConsoleApp(App):
             "[bold $warning]KEYBINDINGS[/]",
             "",
             "  [bold]Tab / Shift+Tab[/]        Cycle channels",
+            "  [bold]Alt+←/→[/]                Jump by word in input",
+            "  [bold]Alt+Backspace[/]          Delete previous word",
             "  [bold]Ctrl+O[/]                 Overview",
             "  [bold]Ctrl+S[/]                 Status",
-            "  [bold]Ctrl+H[/]                 Help",
+            "  [bold]F1[/]                     Help (Ctrl+H on terminals that forward it)",
             "  [bold]Escape[/]                 Back to chat",
             "  [bold]Ctrl+Q[/]                 Quit",
+            "",
+            "[bold $warning]COPY-PASTE[/]",
+            "",
+            "  Hold [bold]Shift[/] while dragging with the mouse to select text for copy-paste.",
+            "  Most modern terminals (iTerm2, Kitty, Alacritty, WezTerm, GNOME Terminal,",
+            "  Windows Terminal) let Shift bypass the TUI's mouse capture.",
         ]
         chat.set_content("Help", lines)
 
@@ -567,15 +579,17 @@ class ConsoleApp(App):
         ]
         sidebar.entities = entity_items
 
-    def action_back_to_chat(self) -> None:
-        """Return to the normal chat view."""
+    async def action_back_to_chat(self) -> None:
+        """Return to the normal chat view, reloading current channel history."""
         if self._current_view == "chat":
             return
+        if self._current_channel:
+            # Delegate: resets view, shows input, and reloads recent history —
+            # equivalent to running /read on the current channel.
+            await self._switch_to_channel(self._current_channel)
+            return
+        # No channel yet — just restore chat view and show the input.
         self._current_view = "chat"
-        chat: ChatPanel = self.query_one(ChatPanel)
-        chat.set_channel(self._current_channel)
-
-        # Re-show input
         try:
             input_widget = self.query_one(self._CHAT_INPUT_ID)
             input_widget.display = True

{agentirc_cli-6.2.0 → agentirc_cli-6.2.1}/culture/console/widgets/chat.py

@@ -5,12 +5,35 @@ from __future__ import annotations
 from datetime import datetime
 
 from textual.app import ComposeResult
+from textual.binding import Binding
 from textual.containers import Vertical
 from textual.message import Message
 from textual.widget import Widget
 from textual.widgets import Input, RichLog, Static
 
 
+class ChatInput(Input):
+    """Input with Alt+Arrow word-jump and Alt+Backspace word-delete."""
+
+    BINDINGS = [
+        Binding("alt+left", "cursor_left_word", "Word left", show=False),
+        Binding("alt+right", "cursor_right_word", "Word right", show=False),
+        Binding(
+            "alt+shift+left",
+            "cursor_left_word(True)",
+            "Select word left",
+            show=False,
+        ),
+        Binding(
+            "alt+shift+right",
+            "cursor_right_word(True)",
+            "Select word right",
+            show=False,
+        ),
+        Binding("alt+backspace", "delete_left_word", "Delete word", show=False),
+    ]
+
+
 class ChatPanel(Widget):
     """Center panel showing the message log and an input field.
 
@@ -75,7 +98,7 @@ class ChatPanel(Widget):
         yield Static("", id="chat-header")
         with Vertical():
             yield RichLog(id="chat-log", markup=True, wrap=True, highlight=False)
-        yield Input(placeholder="Type a message or /command…", id="chat-input")
+        yield ChatInput(placeholder="Type a message or /command…", id="chat-input")
 
     def on_mount(self) -> None:
         self._channel = ""

{agentirc_cli-6.2.0 → agentirc_cli-6.2.1}/culture/observer.py

@@ -205,11 +205,23 @@ class IRCObserver:
     async def send_message(self, target: str, text: str) -> None:
         """Send a PRIVMSG to a channel or nick, then disconnect.
 
+        ``text`` is split on real ``\\n`` bytes into one PRIVMSG per line,
+        since an IRC PRIVMSG must be single-line per RFC 2812. Empty lines
+        (and any embedded ``\\r``) are dropped — IRC can't carry an empty
+        PRIVMSG body, and this keeps multi-line output from emitting no-op
+        frames. If every line is empty, the method returns without
+        connecting.
+
         Uses the same ephemeral connection pattern as the read commands.
         """
-        # Sanitize CR/LF to prevent IRC command injection
+        # Strip CR and LF from the target to prevent IRC command injection
+        # (a newline in the target would let an attacker smuggle a second
+        # protocol line).
         target = target.replace("\r", "").replace("\n", "")
-        text = text.replace("\r", "").replace("\n", " ")
+        # Split on real newlines; drop empty lines and strip CRs
+        lines = [ln for ln in text.replace("\r", "").split("\n") if ln]
+        if not lines:
+            return
 
         reader, writer, nick = await self._connect_and_register()
         try:
@@ -220,7 +232,8 @@ class IRCObserver:
                 # Drain join responses
                 await self._recv_lines(reader, timeout=1.0)
 
-            writer.write(f"PRIVMSG {target} :{text}\r\n".encode())
+            for line in lines:
+                writer.write(f"PRIVMSG {target} :{line}\r\n".encode())
             await writer.drain()
         finally:
             await self._disconnect(writer)

{agentirc_cli-6.2.0 → agentirc_cli-6.2.1}/docs/reference/cli/index.md

@@ -244,6 +244,23 @@ culture channel message "#general" "hello from the CLI"
 
 Uses an ephemeral IRC connection — no daemon required.
 
+**Multi-line messages.** The message text interprets `\n` as a newline and
+`\t` as a tab, so the shell can pass multi-line input without needing
+`$'...'` quoting. Each line is sent as a separate IRC `PRIVMSG` (required by
+RFC 2812 — a single `PRIVMSG` can't span lines). Empty lines are dropped.
+
+```bash
+culture channel message "#general" "line one\nline two\nline three"
+# → three separate PRIVMSG lines on the channel
+```
+
+To send a literal backslash-n (two characters) escape the backslash:
+
+```bash
+culture channel message "#general" "use \\n in your string"
+# → sends the text: use \n in your string
+```
+
 ### `culture agent message`
 
 Send a message directly to an agent.

{agentirc_cli-6.2.0 → agentirc_cli-6.2.1}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "agentirc-cli"
-version = "6.2.0"
+version = "6.2.1"
 description = "Legacy alias for culture — install culture instead"
 readme = "README.md"
 license = "MIT"

agentirc_cli-6.2.1/tests/test_console_fixes_224_227.py

@@ -0,0 +1,199 @@
+"""Tests for console fixes covering issues #224, #225, #226, #227.
+
+- #224  `/read` on exit overview + mouse copy-paste documentation
+- #225  Newlines in IRC messages — CLI escape interpretation + observer split
+- #226  Alt+Arrow word-jump (and Alt+Backspace) in chat input
+- #227  Tab cycles channels (priority binding over Screen focus-cycling)
+"""
+
+from __future__ import annotations
+
+import argparse
+
+import pytest
+
+from culture.cli.channel import _cmd_message, _interpret_escapes
+from culture.console.app import ConsoleApp
+from culture.console.widgets.chat import ChatInput
+from culture.observer import IRCObserver
+
+# ---------------------------------------------------------------------------
+# #225 — CLI escape interpretation
+# ---------------------------------------------------------------------------
+
+
+class TestInterpretEscapes:
+    """Convert shell-literal \\n / \\t / \\\\ sequences to real chars."""
+
+    def test_single_newline(self):
+        assert _interpret_escapes(r"a\nb") == "a\nb"
+
+    def test_multiple_newlines(self):
+        assert _interpret_escapes(r"a\nb\nc") == "a\nb\nc"
+
+    def test_tab(self):
+        assert _interpret_escapes(r"col1\tcol2") == "col1\tcol2"
+
+    def test_mixed(self):
+        assert _interpret_escapes(r"line1\n\tindented") == "line1\n\tindented"
+
+    def test_no_escapes(self):
+        assert _interpret_escapes("plain text") == "plain text"
+
+    def test_real_newlines_preserved(self):
+        # Real newlines (e.g., from heredoc) passthrough unchanged.
+        assert _interpret_escapes("a\nb") == "a\nb"
+
+    def test_double_backslash_is_literal_backslash(self):
+        # \\ collapses to a single backslash — so \\n stays as literal
+        # backslash-n (two chars), not as a newline.
+        assert _interpret_escapes(r"a\\b") == r"a\b"
+        assert _interpret_escapes(r"use \\n in your text") == r"use \n in your text"
+
+    def test_other_escapes_untouched(self):
+        # Only \n, \t, \\ are recognised. Any other \x pair is passed through
+        # with the backslash intact — no \x..  / \u.... / \r interpretation.
+        assert _interpret_escapes(r"a\fb") == r"a\fb"
+        assert _interpret_escapes(r"a\rb") == r"a\rb"
+        assert _interpret_escapes(r"a\xb") == r"a\xb"
+        # Trailing lone backslash passes through
+        assert _interpret_escapes("a\\") == "a\\"
+
+    def test_interpreted_newline_is_real(self):
+        # The literal \n we produce is a real newline, not a backslash-n.
+        assert "\\n" not in _interpret_escapes(r"a\nb")
+
+
+class TestMessageEmptyAfterInterpret:
+    """_cmd_message must exit 1 if nothing would be sent after interpretation."""
+
+    def _args(self, text: str) -> argparse.Namespace:
+        return argparse.Namespace(
+            target="#test",
+            text=text,
+            config="~/.culture/server.yaml",
+        )
+
+    def test_only_whitespace_and_newlines_rejected(self, capsys):
+        # Pre-interpretation pass (non-empty string), but after interpretation
+        # the message is all empty lines — nothing would actually be sent.
+        with pytest.raises(SystemExit) as exc:
+            _cmd_message(self._args(r"\n\n\n"))
+        assert exc.value.code == 1
+        assert "no non-empty line" in capsys.readouterr().err
+
+    def test_whitespace_only_rejected_before_interpretation(self, capsys):
+        # The existing strip check rejects pure whitespace before we get to
+        # the interpretation step.
+        with pytest.raises(SystemExit) as exc:
+            _cmd_message(self._args("   "))
+        assert exc.value.code == 1
+        assert "cannot be empty" in capsys.readouterr().err
+
+
+# ---------------------------------------------------------------------------
+# #225 — observer multi-line PRIVMSG
+# ---------------------------------------------------------------------------
+
+
+@pytest.mark.asyncio
+async def test_observer_send_message_splits_newlines(server, make_client):
+    """Issue #225: send_message emits one PRIVMSG per newline."""
+    # Receiver joins and listens
+    receiver = await make_client(nick="testserv-recv", user="recv")
+    await receiver.send("JOIN #multiline")
+    await receiver.recv_all(timeout=0.5)
+
+    observer = IRCObserver(
+        host="127.0.0.1",
+        port=server.config.port,
+        server_name=server.config.name,
+    )
+    await observer.send_message("#multiline", "line one\nline two\nline three")
+
+    lines = await receiver.recv_all(timeout=1.0)
+    joined = "\n".join(lines)
+
+    # Each line must arrive as a separate PRIVMSG
+    assert joined.count("PRIVMSG #multiline") >= 3
+    assert "line one" in joined
+    assert "line two" in joined
+    assert "line three" in joined
+
+
+@pytest.mark.asyncio
+async def test_observer_send_message_drops_empty_lines(server, make_client):
+    """Empty lines between real lines are dropped (IRC can't send empty PRIVMSG)."""
+    receiver = await make_client(nick="testserv-recv2", user="recv2")
+    await receiver.send("JOIN #drops")
+    await receiver.recv_all(timeout=0.5)
+
+    observer = IRCObserver(
+        host="127.0.0.1",
+        port=server.config.port,
+        server_name=server.config.name,
+    )
+    await observer.send_message("#drops", "a\n\n\nb")
+
+    lines = await receiver.recv_all(timeout=1.0)
+    joined = "\n".join(lines)
+    # Exactly two PRIVMSGs — the three blank segments are skipped
+    assert joined.count("PRIVMSG #drops") == 2
+
+
+# ---------------------------------------------------------------------------
+# #226 — ChatInput bindings
+# ---------------------------------------------------------------------------
+
+
+class TestChatInputBindings:
+    """ChatInput must expose Alt+Arrow word-jump and Alt+Backspace."""
+
+    def _binding_map(self) -> dict[str, str]:
+        return {b.key: b.action for b in ChatInput.BINDINGS}
+
+    def test_alt_left_word_jump(self):
+        assert self._binding_map().get("alt+left") == "cursor_left_word"
+
+    def test_alt_right_word_jump(self):
+        assert self._binding_map().get("alt+right") == "cursor_right_word"
+
+    def test_alt_shift_selects_word(self):
+        m = self._binding_map()
+        assert m.get("alt+shift+left") == "cursor_left_word(True)"
+        assert m.get("alt+shift+right") == "cursor_right_word(True)"
+
+    def test_alt_backspace_deletes_word(self):
+        assert self._binding_map().get("alt+backspace") == "delete_left_word"
+
+
+# ---------------------------------------------------------------------------
+# #227 — Tab cycles channels (priority binding)
+# ---------------------------------------------------------------------------
+
+
+class TestConsoleAppBindings:
+    """App-level bindings for #227 and the Ctrl+H help follow-up."""
+
+    def _bindings(self):
+        return {b.key: b for b in ConsoleApp.BINDINGS}
+
+    def test_tab_cycles_next_channel(self):
+        b = self._bindings()["tab"]
+        assert b.action == "next_channel"
+        assert b.priority is True, "Tab must use priority to beat Screen focus-cycling"
+
+    def test_shift_tab_cycles_prev_channel(self):
+        b = self._bindings()["shift+tab"]
+        assert b.action == "prev_channel"
+        assert b.priority is True
+
+    def test_help_is_bound_to_f1(self):
+        # F1 is the primary help key — most terminals eat Ctrl+H as backspace.
+        f1 = self._bindings()["f1"]
+        assert f1.action == "show_help"
+
+    def test_ctrl_h_remains_as_secondary_help(self):
+        # Secondary binding still present for terminals with modifyOtherKeys.
+        ctrl_h = self._bindings()["ctrl+h"]
+        assert ctrl_h.action == "show_help"

{agentirc_cli-6.2.0 → agentirc_cli-6.2.1}/uv.lock

@@ -561,7 +561,7 @@ wheels = [
 
 [[package]]
 name = "culture"
-version = "6.2.0"
+version = "6.2.1"
 source = { editable = "." }
 dependencies = [
     { name = "aiohttp" },