agentirc-cli 4.3.7__tar.gz → 4.4.0__tar.gz

{agentirc_cli-4.3.7 → agentirc_cli-4.4.0}/CHANGELOG.md

@@ -4,6 +4,20 @@ All notable changes to this project will be documented in this file.
 
 Format follows [Keep a Changelog](https://keepachangelog.com/).
 
+## [4.4.0] - 2026-04-07
+
+
+### Added
+
+- SQLite-backed persistent channel history (survives server restarts)
+- --data-dir CLI flag for server start (default: ~/.culture/data)
+
+
+### Fixed
+
+- Multi-line messages truncated to first line in send_privmsg and thread methods
+- data_dir never wired to ServerConfig, silently disabling room/thread persistence
+
 ## [4.3.7] - 2026-04-07
 
 

{agentirc_cli-4.3.7 → agentirc_cli-4.4.0}/PKG-INFO

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

{agentirc_cli-4.3.7 → agentirc_cli-4.4.0}/culture/cli/server.py

@@ -74,6 +74,11 @@ def register(subparsers: argparse._SubParsersAction) -> None:
         action="store_true",
         help="Run in foreground (for service managers)",
     )
+    srv_start.add_argument(
+        "--data-dir",
+        default=os.path.expanduser("~/.culture/data"),
+        help="Data directory for persistent storage (default: ~/.culture/data)",
+    )
 
     srv_stop = server_sub.add_parser("stop", help="Stop the IRC server daemon")
     srv_stop.add_argument("--name", default=None, help=_SERVER_NAME_HELP)
@@ -279,7 +284,9 @@ def _run_foreground(args: argparse.Namespace, pid_name: str, links: list) -> Non
     print(f"  Webhook port: {args.webhook_port}")
     _maybe_set_default_server(args.name)
     try:
-        asyncio.run(_run_server(args.name, args.host, args.port, links, args.webhook_port))
+        asyncio.run(
+            _run_server(args.name, args.host, args.port, links, args.webhook_port, args.data_dir)
+        )
     finally:
         remove_pid(pid_name)
 
@@ -369,7 +376,9 @@ def _daemonize_server(args: argparse.Namespace, pid_name: str, links: list) -> N
     write_pid(pid_name, os.getpid())
 
     try:
-        asyncio.run(_run_server(args.name, args.host, args.port, links, args.webhook_port))
+        asyncio.run(
+            _run_server(args.name, args.host, args.port, links, args.webhook_port, args.data_dir)
+        )
     finally:
         remove_pid(pid_name)
         os._exit(0)
@@ -391,14 +400,24 @@ def _server_start(args: argparse.Namespace) -> None:
 
 
 async def _run_server(
-    name: str, host: str, port: int, links: list | None = None, webhook_port: int = 7680
+    name: str,
+    host: str,
+    port: int,
+    links: list | None = None,
+    webhook_port: int = 7680,
+    data_dir: str = "",
 ) -> None:
     """Run the IRC server (called in the daemon child process)."""
     from culture.server.config import ServerConfig
     from culture.server.ircd import IRCd
 
     config = ServerConfig(
-        name=name, host=host, port=port, webhook_port=webhook_port, links=links or []
+        name=name,
+        host=host,
+        port=port,
+        webhook_port=webhook_port,
+        links=links or [],
+        data_dir=data_dir,
     )
     ircd = IRCd(config)
     await ircd.start()

{agentirc_cli-4.3.7 → agentirc_cli-4.4.0}/culture/clients/acp/irc_transport.py

@@ -87,16 +87,26 @@ class IRCTransport:
         self.connected = False
 
     async def send_privmsg(self, target: str, text: str) -> None:
-        await self._send_raw(f"PRIVMSG {target} :{text}")
+        for line in text.splitlines():
+            if line:
+                await self._send_raw(f"PRIVMSG {target} :{line}")
 
     async def send_thread_create(self, channel: str, thread_name: str, text: str) -> None:
-        await self._send_raw(f"THREAD CREATE {channel} {thread_name} :{text}")
+        lines = [l for l in text.splitlines() if l]
+        if not lines:
+            return
+        await self._send_raw(f"THREAD CREATE {channel} {thread_name} :{lines[0]}")
+        for line in lines[1:]:
+            await self._send_raw(f"THREAD REPLY {channel} {thread_name} :{line}")
 
     async def send_thread_reply(self, channel: str, thread_name: str, text: str) -> None:
-        await self._send_raw(f"THREAD REPLY {channel} {thread_name} :{text}")
+        for line in text.splitlines():
+            if line:
+                await self._send_raw(f"THREAD REPLY {channel} {thread_name} :{line}")
 
     async def send_thread_close(self, channel: str, thread_name: str, summary: str) -> None:
-        await self._send_raw(f"THREADCLOSE {channel} {thread_name} :{summary}")
+        clean = " ".join(summary.splitlines()).strip()
+        await self._send_raw(f"THREADCLOSE {channel} {thread_name} :{clean}")
 
     async def send_threads_list(self, channel: str) -> None:
         await self._send_raw(f"THREADS {channel}")

{agentirc_cli-4.3.7 → agentirc_cli-4.4.0}/culture/clients/claude/irc_transport.py

@@ -87,16 +87,26 @@ class IRCTransport:
         self.connected = False
 
     async def send_privmsg(self, target: str, text: str) -> None:
-        await self._send_raw(f"PRIVMSG {target} :{text}")
+        for line in text.splitlines():
+            if line:
+                await self._send_raw(f"PRIVMSG {target} :{line}")
 
     async def send_thread_create(self, channel: str, thread_name: str, text: str) -> None:
-        await self._send_raw(f"THREAD CREATE {channel} {thread_name} :{text}")
+        lines = [l for l in text.splitlines() if l]
+        if not lines:
+            return
+        await self._send_raw(f"THREAD CREATE {channel} {thread_name} :{lines[0]}")
+        for line in lines[1:]:
+            await self._send_raw(f"THREAD REPLY {channel} {thread_name} :{line}")
 
     async def send_thread_reply(self, channel: str, thread_name: str, text: str) -> None:
-        await self._send_raw(f"THREAD REPLY {channel} {thread_name} :{text}")
+        for line in text.splitlines():
+            if line:
+                await self._send_raw(f"THREAD REPLY {channel} {thread_name} :{line}")
 
     async def send_thread_close(self, channel: str, thread_name: str, summary: str) -> None:
-        await self._send_raw(f"THREADCLOSE {channel} {thread_name} :{summary}")
+        clean = " ".join(summary.splitlines()).strip()
+        await self._send_raw(f"THREADCLOSE {channel} {thread_name} :{clean}")
 
     async def send_threads_list(self, channel: str) -> None:
         await self._send_raw(f"THREADS {channel}")

{agentirc_cli-4.3.7 → agentirc_cli-4.4.0}/culture/clients/codex/irc_transport.py

@@ -87,16 +87,26 @@ class IRCTransport:
         self.connected = False
 
     async def send_privmsg(self, target: str, text: str) -> None:
-        await self._send_raw(f"PRIVMSG {target} :{text}")
+        for line in text.splitlines():
+            if line:
+                await self._send_raw(f"PRIVMSG {target} :{line}")
 
     async def send_thread_create(self, channel: str, thread_name: str, text: str) -> None:
-        await self._send_raw(f"THREAD CREATE {channel} {thread_name} :{text}")
+        lines = [l for l in text.splitlines() if l]
+        if not lines:
+            return
+        await self._send_raw(f"THREAD CREATE {channel} {thread_name} :{lines[0]}")
+        for line in lines[1:]:
+            await self._send_raw(f"THREAD REPLY {channel} {thread_name} :{line}")
 
     async def send_thread_reply(self, channel: str, thread_name: str, text: str) -> None:
-        await self._send_raw(f"THREAD REPLY {channel} {thread_name} :{text}")
+        for line in text.splitlines():
+            if line:
+                await self._send_raw(f"THREAD REPLY {channel} {thread_name} :{line}")
 
     async def send_thread_close(self, channel: str, thread_name: str, summary: str) -> None:
-        await self._send_raw(f"THREADCLOSE {channel} {thread_name} :{summary}")
+        clean = " ".join(summary.splitlines()).strip()
+        await self._send_raw(f"THREADCLOSE {channel} {thread_name} :{clean}")
 
     async def send_threads_list(self, channel: str) -> None:
         await self._send_raw(f"THREADS {channel}")

{agentirc_cli-4.3.7 → agentirc_cli-4.4.0}/culture/clients/copilot/irc_transport.py

@@ -87,16 +87,26 @@ class IRCTransport:
         self.connected = False
 
     async def send_privmsg(self, target: str, text: str) -> None:
-        await self._send_raw(f"PRIVMSG {target} :{text}")
+        for line in text.splitlines():
+            if line:
+                await self._send_raw(f"PRIVMSG {target} :{line}")
 
     async def send_thread_create(self, channel: str, thread_name: str, text: str) -> None:
-        await self._send_raw(f"THREAD CREATE {channel} {thread_name} :{text}")
+        lines = [l for l in text.splitlines() if l]
+        if not lines:
+            return
+        await self._send_raw(f"THREAD CREATE {channel} {thread_name} :{lines[0]}")
+        for line in lines[1:]:
+            await self._send_raw(f"THREAD REPLY {channel} {thread_name} :{line}")
 
     async def send_thread_reply(self, channel: str, thread_name: str, text: str) -> None:
-        await self._send_raw(f"THREAD REPLY {channel} {thread_name} :{text}")
+        for line in text.splitlines():
+            if line:
+                await self._send_raw(f"THREAD REPLY {channel} {thread_name} :{line}")
 
     async def send_thread_close(self, channel: str, thread_name: str, summary: str) -> None:
-        await self._send_raw(f"THREADCLOSE {channel} {thread_name} :{summary}")
+        clean = " ".join(summary.splitlines()).strip()
+        await self._send_raw(f"THREADCLOSE {channel} {thread_name} :{clean}")
 
     async def send_threads_list(self, channel: str) -> None:
         await self._send_raw(f"THREADS {channel}")

{agentirc_cli-4.3.7 → agentirc_cli-4.4.0}/culture/protocol/extensions/history.md

@@ -107,6 +107,11 @@ An empty result set returns only the HISTORYEND line.
 
 - History is stored in memory with a configurable maximum per channel
   (default: 10,000 entries per channel)
-- History does not persist across server restarts
+- When `data_dir` is configured (default: `~/.culture/data/`), history is
+  persisted to SQLite and survives server restarts
+- Entries older than 30 days (configurable via `retention_days`) are
+  automatically pruned on startup
+- The in-memory buffer remains the primary read cache; SQLite provides
+  durability
 - Both PRIVMSG and NOTICE to channels are recorded
 - Direct messages are never recorded

agentirc_cli-4.4.0/culture/server/history_store.py

@@ -0,0 +1,91 @@
+"""SQLite disk persistence for channel message history."""
+
+from __future__ import annotations
+
+import logging
+import sqlite3
+import time
+from collections import deque
+from pathlib import Path
+
+logger = logging.getLogger(__name__)
+
+
+class HistoryStore:
+    """Save and load channel message history to/from SQLite."""
+
+    def __init__(self, data_dir: str):
+        db_dir = Path(data_dir)
+        db_dir.mkdir(parents=True, exist_ok=True)
+        self._db_path = db_dir / "history.db"
+        self._conn = sqlite3.connect(str(self._db_path), check_same_thread=False)
+        self._conn.execute("PRAGMA journal_mode=WAL")
+        self._conn.execute("""CREATE TABLE IF NOT EXISTS history (
+                id INTEGER PRIMARY KEY AUTOINCREMENT,
+                channel TEXT NOT NULL,
+                nick TEXT NOT NULL,
+                text TEXT NOT NULL,
+                timestamp REAL NOT NULL
+            )""")
+        self._conn.execute(
+            "CREATE INDEX IF NOT EXISTS idx_history_channel_ts ON history(channel, timestamp, id)"
+        )
+        self._conn.commit()
+
+    def append(self, channel: str, nick: str, text: str, timestamp: float) -> None:
+        """Insert a single history entry (batched — not committed per call)."""
+        self._conn.execute(
+            "INSERT INTO history (channel, nick, text, timestamp) VALUES (?, ?, ?, ?)",
+            (channel, nick, text, timestamp),
+        )
+
+    def get_recent(self, channel: str, count: int) -> list[dict]:
+        """Return the last *count* entries for a channel, in chronological order."""
+        cur = self._conn.execute(
+            "SELECT nick, text, timestamp FROM history "
+            "WHERE channel = ? ORDER BY timestamp DESC, id DESC LIMIT ?",
+            (channel, count),
+        )
+        rows = cur.fetchall()
+        return [{"nick": r[0], "text": r[1], "timestamp": r[2]} for r in reversed(rows)]
+
+    def search(self, channel: str, term: str) -> list[dict]:
+        """Case-insensitive substring search within a channel."""
+        escaped = term.replace("\\", "\\\\").replace("%", "\\%").replace("_", "\\_")
+        cur = self._conn.execute(
+            "SELECT nick, text, timestamp FROM history "
+            "WHERE channel = ? AND text LIKE ? ESCAPE '\\' ORDER BY timestamp ASC",
+            (channel, f"%{escaped}%"),
+        )
+        return [{"nick": r[0], "text": r[1], "timestamp": r[2]} for r in cur]
+
+    def load_channels(self, maxlen: int) -> dict[str, deque]:
+        """Load the last *maxlen* entries per channel for startup restore.
+
+        Returns a dict mapping channel names to deques of
+        ``{"nick": ..., "text": ..., "timestamp": ...}`` dicts.
+        """
+        cur = self._conn.execute("SELECT DISTINCT channel FROM history")
+        channels: dict[str, deque] = {}
+        for (channel,) in cur:
+            entries = self.get_recent(channel, maxlen)
+            channels[channel] = deque(entries, maxlen=maxlen)
+        return channels
+
+    def prune(self, max_age_days: int) -> int:
+        """Delete entries older than *max_age_days*.  Returns rows deleted."""
+        cutoff = time.time() - (max_age_days * 86400)
+        cur = self._conn.execute("DELETE FROM history WHERE timestamp < ?", (cutoff,))
+        self._conn.commit()
+        deleted = cur.rowcount
+        if deleted:
+            logger.info("Pruned %d history entries older than %d days", deleted, max_age_days)
+        return deleted
+
+    def close(self) -> None:
+        """Flush pending writes and close the database connection."""
+        try:
+            self._conn.commit()
+        except sqlite3.Error:
+            pass
+        self._conn.close()

{agentirc_cli-4.3.7 → agentirc_cli-4.4.0}/culture/server/skills/history.py

@@ -1,6 +1,7 @@
 # server/skills/history.py
 from __future__ import annotations
 
+import logging
 from collections import deque
 from dataclasses import dataclass
 from typing import TYPE_CHECKING
@@ -12,6 +13,8 @@ from culture.server.skill import Event, EventType, Skill
 if TYPE_CHECKING:
     from culture.server.client import Client
 
+logger = logging.getLogger(__name__)
+
 
 @dataclass
 class HistoryEntry:
@@ -24,9 +27,51 @@ class HistorySkill(Skill):
     name = "history"
     commands = {"HISTORY"}
 
-    def __init__(self, maxlen: int = 10000):
+    def __init__(self, maxlen: int = 10000, retention_days: int = 30):
         self.maxlen = maxlen
+        self.retention_days = retention_days
         self._channels: dict[str, deque[HistoryEntry]] = {}
+        self._store = None
+
+    async def start(self, server) -> None:
+        await super().start(server)
+        self._restore_history()
+
+    async def stop(self) -> None:
+        if self._store is not None:
+            self._store.close()
+            self._store = None
+
+    def _restore_history(self) -> None:
+        """Reload persisted history from SQLite on startup."""
+        if not self.server.config.data_dir:
+            return
+        from culture.server.history_store import HistoryStore
+
+        try:
+            store = HistoryStore(self.server.config.data_dir)
+            store.prune(self.retention_days)
+            channel_data = store.load_channels(self.maxlen)
+        except Exception:
+            logger.warning(
+                "Failed to open history database — falling back to in-memory",
+                exc_info=True,
+            )
+            return
+
+        self._store = store
+        for channel, entries in channel_data.items():
+            buf = deque(maxlen=self.maxlen)
+            for e in entries:
+                buf.append(HistoryEntry(nick=e["nick"], text=e["text"], timestamp=e["timestamp"]))
+            self._channels[channel] = buf
+        total = sum(len(d) for d in self._channels.values())
+        if total:
+            logger.info(
+                "Restored %d history entries across %d channels",
+                total,
+                len(self._channels),
+            )
 
     async def on_event(self, event: Event) -> None:
         if event.type == EventType.MESSAGE and event.channel is not None:
@@ -38,6 +83,8 @@ class HistorySkill(Skill):
                     timestamp=event.timestamp,
                 )
             )
+            if self._store is not None:
+                self._store.append(event.channel, event.nick, event.data["text"], event.timestamp)
 
     def get_recent(self, channel: str, count: int) -> list[HistoryEntry]:
         if count <= 0:

agentirc_cli-4.4.0/docs/persistent-history.md

@@ -0,0 +1,61 @@
+# Persistent Channel History
+
+Channel message history is now backed by SQLite, surviving server restarts.
+
+## How It Works
+
+The server maintains an in-memory buffer (deque, 10K entries/channel) as the
+hot read cache. When `data_dir` is configured, every channel message is also
+appended to `{data_dir}/history.db`. On startup, the deque is restored from
+SQLite.
+
+Writes are batched (no per-message commit) to avoid blocking the event loop.
+Pending writes are flushed on shutdown.
+
+## Configuration
+
+The `--data-dir` flag on `culture server start` controls where persistent data
+is stored. It defaults to `~/.culture/data/`.
+
+```bash
+# Default (persistence enabled)
+culture server start --name spark
+
+# Custom path
+culture server start --name spark --data-dir /var/lib/culture/data
+
+# Disable persistence (empty string)
+culture server start --name spark --data-dir ""
+```
+
+When `data_dir` is empty, the server operates in-memory only (original
+behavior). All other persistent features (rooms, threads) also use this
+directory.
+
+## Retention
+
+Entries older than 30 days are automatically pruned on startup. The retention
+period is configurable via the `retention_days` parameter on `HistorySkill`
+(default: 30).
+
+## Multi-line Messages
+
+Agent transports (`send_privmsg`, `send_thread_reply`, etc.) now split
+multi-line text into separate IRC messages using `str.splitlines()`. This
+handles `\n`, `\r\n`, and `\r` uniformly, preventing truncation and CRLF
+injection.
+
+For `send_thread_create`, the first line becomes the CREATE command and
+subsequent lines are sent as REPLY commands. For `send_thread_close`, all
+line breaks are collapsed to spaces.
+
+## Protocol
+
+No protocol changes. The `HISTORY RECENT` and `HISTORY SEARCH` commands work
+identically. See `protocol/extensions/history.md` for the wire format.
+
+## Graceful Degradation
+
+If the SQLite database is corrupt, locked, or inaccessible at startup, the
+server logs a warning and falls back to in-memory history. The server will not
+crash due to a database error.

{agentirc_cli-4.3.7 → agentirc_cli-4.4.0}/packages/agent-harness/irc_transport.py

@@ -88,16 +88,26 @@ class IRCTransport:
         self.connected = False
 
     async def send_privmsg(self, target: str, text: str) -> None:
-        await self._send_raw(f"PRIVMSG {target} :{text}")
+        for line in text.splitlines():
+            if line:
+                await self._send_raw(f"PRIVMSG {target} :{line}")
 
     async def send_thread_create(self, channel: str, thread_name: str, text: str) -> None:
-        await self._send_raw(f"THREAD CREATE {channel} {thread_name} :{text}")
+        lines = [l for l in text.splitlines() if l]
+        if not lines:
+            return
+        await self._send_raw(f"THREAD CREATE {channel} {thread_name} :{lines[0]}")
+        for line in lines[1:]:
+            await self._send_raw(f"THREAD REPLY {channel} {thread_name} :{line}")
 
     async def send_thread_reply(self, channel: str, thread_name: str, text: str) -> None:
-        await self._send_raw(f"THREAD REPLY {channel} {thread_name} :{text}")
+        for line in text.splitlines():
+            if line:
+                await self._send_raw(f"THREAD REPLY {channel} {thread_name} :{line}")
 
     async def send_thread_close(self, channel: str, thread_name: str, summary: str) -> None:
-        await self._send_raw(f"THREADCLOSE {channel} {thread_name} :{summary}")
+        clean = " ".join(summary.splitlines()).strip()
+        await self._send_raw(f"THREADCLOSE {channel} {thread_name} :{clean}")
 
     async def send_threads_list(self, channel: str) -> None:
         await self._send_raw(f"THREADS {channel}")

{agentirc_cli-4.3.7 → agentirc_cli-4.4.0}/pyproject.toml

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