agent-chat-plugin 0.2.1__tar.gz → 0.3.0__tar.gz

{agent_chat_plugin-0.2.1 → agent_chat_plugin-0.3.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: agent-chat-plugin
-Version: 0.2.1
+Version: 0.3.0
 Summary: Peer AI agents coordinate through markdown messages in shared channel folders — no orchestrator, autonomous zero-token waiting, cross-platform.
 Author: n24q02m
 License: Apache-2.0

{agent_chat_plugin-0.2.1 → agent_chat_plugin-0.3.0}/agent_chat_plugin.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: agent-chat-plugin
-Version: 0.2.1
+Version: 0.3.0
 Summary: Peer AI agents coordinate through markdown messages in shared channel folders — no orchestrator, autonomous zero-token waiting, cross-platform.
 Author: n24q02m
 License: Apache-2.0

{agent_chat_plugin-0.2.1 → agent_chat_plugin-0.3.0}/chat.py

@@ -30,6 +30,8 @@ import sys
 import time
 from pathlib import Path
 
+import heapq
+
 # --- root + small helpers ----------------------------------------------------
 
 
@@ -56,6 +58,10 @@ def _frontmatter_value(value) -> str:
     return re.sub(r"[\r\n]+", " ", str(value))
 
 
+class AgentChatError(Exception):
+    pass
+
+
 def die(msg: str, code: int = 1):
     print(f"agent-chat: {msg}", file=sys.stderr)
     raise SystemExit(code)
@@ -66,8 +72,13 @@ def die(msg: str, code: int = 1):
 
 def _check_safe_name(name: str, kind: str):
     """Prevent path traversal vulnerabilities."""
-    if not name or "/" in name or "\\" in name or name in (".", ".."):
-        die(f"invalid {kind} name (path traversal blocked): '{name}'")
+    if not name or "/" in name or "\\" in name or ":" in name or name in (".", ".."):
+        raise AgentChatError(f"invalid {kind} name (path traversal blocked): '{name}'")
+    if name.startswith(".") or name.startswith("_"):
+        raise AgentChatError(f"invalid {kind} name (reserved prefix blocked): '{name}'")
+
+
+_TASK_MARKER_RE = re.compile(r"task-[A-Za-z0-9][A-Za-z0-9_-]*\.md")
 
 
 def channel_dir(root: Path, channel: str) -> Path:
@@ -78,7 +89,9 @@ def channel_dir(root: Path, channel: str) -> Path:
 def require_channel(root: Path, channel: str) -> Path:
     d = channel_dir(root, channel)
     if not (d / "_meta.json").exists():
-        die(f"channel '{channel}' not found under {root} (run: init {channel})")
+        raise AgentChatError(
+            f"channel '{channel}' not found under {root} (run: init {channel})"
+        )
     return d
 
 
@@ -117,7 +130,7 @@ def parse_frontmatter(path: Path) -> dict:
             if not found_end:
                 return meta
             meta = temp_meta
-    except OSError:
+    except (OSError, UnicodeDecodeError):
         return meta
     # Normalize `to` -> list of recipients (empty == everyone).
     raw = meta.get("to", "").strip()
@@ -163,7 +176,9 @@ def _acquire_lock(chan: Path, timeout: float = 10.0, stale: float = 30.0) -> Pat
             except FileNotFoundError:
                 continue
             if time.time() - start > timeout:
-                die("could not acquire channel seq lock (another poster is stuck?)")
+                raise AgentChatError(
+                    "could not acquire channel seq lock (another poster is stuck?)"
+                )
             time.sleep(0.05)
 
 
@@ -222,7 +237,7 @@ def cmd_init(root: Path, a):
     (d / ".cursors").mkdir(exist_ok=True)
     meta_path = d / "_meta.json"
     if meta_path.exists():
-        die(f"channel '{a.channel}' already exists")
+        raise AgentChatError(f"channel '{a.channel}' already exists")
     members = [m.strip() for m in (a.members or "").split(",") if m.strip()]
     meta_path.write_text(
         json.dumps(
@@ -236,7 +251,8 @@ def cmd_init(root: Path, a):
         ),
         encoding="utf-8",
     )
-    print(f"created channel '{a.channel}' at {d}  members={members or '(open)'}")
+    m_str = ", ".join(members) if members else "(open)"
+    print(f"created channel '{a.channel}' at {d}  members={m_str}")
 
 
 def cmd_channels(root: Path, a):
@@ -264,9 +280,15 @@ def cmd_channels(root: Path, a):
         last = "-"
         if last_path is not None:
             lm = parse_frontmatter(last_path)
-            last = f"#{last_seq} {lm.get('from', '?')}: {lm.get('title', '')[:40]}"
+            title = lm.get("title", "")
+            if len(title) > 40:
+                title = title[:37] + "..."
+            last = f"#{last_seq} {lm.get('from', '?')}: {title}"
+        members_str = ", ".join(meta.get("members", [])) or "(open)"
+        if len(members_str) > 40:
+            members_str = members_str[:37] + "..."
         rows.append(
-            (chan.name, ",".join(meta.get("members", [])) or "(open)", count, last)
+            (chan.name, members_str, count, last)
         )
     if not rows:
         print(f"(no channels yet under {root})")
@@ -280,26 +302,34 @@ def cmd_channels(root: Path, a):
 
 def cmd_roster(root: Path, a):
     d = require_channel(root, a.channel)
-    meta = json.loads((d / "_meta.json").read_text(encoding="utf-8"))
+    try:
+        meta = json.loads((d / "_meta.json").read_text(encoding="utf-8"))
+    except (OSError, ValueError):
+        raise AgentChatError(f"could not read or parse _meta.json for channel '{a.channel}'")
     print(f"channel : {meta.get('channel')}")
     print(f"topic   : {meta.get('topic') or '(none)'}")
     print(f"members : {', '.join(meta.get('members', [])) or '(open)'}")
-    print(f"messages: {len(message_files(d))}")
+    count = sum(1 for p in d.glob("*.md") if _seq_from_name(p.name) is not None)
+    print(f"messages: {count}")
 
 
 def _read_body(a) -> str:
     if a.body is not None:
         return a.body
     if a.body_file:
-        return Path(a.body_file).read_text(encoding="utf-8")
+        try:
+            return Path(a.body_file).read_text(encoding="utf-8")
+        except OSError as e:
+            raise AgentChatError(f"could not read body file: {e}")
     # Default: read from stdin so agents can pipe long markdown bodies.
     if sys.stdin.isatty():
         print(
-            "agent-chat: Enter message body; send EOF when finished.", file=sys.stderr
+            "agent-chat: Enter message body; press Ctrl-D (or Ctrl-Z and Enter on Windows) to finish.",
+            file=sys.stderr,
         )
     data = sys.stdin.read()
     if not data.strip():
-        die("empty body (pass --body, --body-file, or pipe via stdin)")
+        raise AgentChatError("empty body (pass --body, --body-file, or pipe via stdin)")
     return data
 
 
@@ -349,16 +379,29 @@ def cmd_read(root: Path, a):
     d = require_channel(root, a.channel)
     cur = 0 if a.all else read_cursor(d, a.agent)
     shown = 0
-    for p in message_files(d):
+
+    # Optimization: One O(N) glob scan to find both top seq and unread messages,
+    # avoiding O(N log N) message_files sort and redundant max_seq glob.
+    found = []
+    top = 0
+    for p in d.glob("*.md"):
         seq = _seq_from_name(p.name)
-        if seq <= cur:
+        if seq is None:
             continue
+        if seq > top:
+            top = seq
+        if seq > cur:
+            found.append((seq, p))
+
+    found.sort(key=lambda x: x[0])
+
+    for seq, p in found:
         meta = parse_frontmatter(p)
         if not a.all and not is_relevant(meta, a.agent):
             continue
         _print_message(p)
         shown += 1
-    top = max_seq(d)
+
     if not a.peek:
         write_cursor(d, a.agent, top)
     if shown == 0:
@@ -371,14 +414,25 @@ def cmd_wait(root: Path, a):
     deadline = time.time() + a.timeout
     while True:
         found = []
-        for p in message_files(d):
-            seq = _seq_from_name(p.name)
-            if seq <= cur:
-                continue
-            meta = parse_frontmatter(p)
-            if is_relevant(meta, a.agent):
-                found.append(p)
+        # Optimization: use os.scandir to avoid Path instantiation overhead for
+        # thousands of old messages per tick.
+        try:
+            with os.scandir(d) as it:
+                for entry in it:
+                    if not entry.name.endswith(".md"):
+                        continue
+                    seq = _seq_from_name(entry.name)
+                    if seq is None or seq <= cur:
+                        continue
+                    p = Path(entry.path)
+                    meta = parse_frontmatter(p)
+                    if is_relevant(meta, a.agent):
+                        found.append(p)
+        except OSError:
+            pass
         if found:
+            # Sort only the newly found messages
+            found.sort(key=lambda p: _seq_from_name(p.name))
             for p in found:
                 _print_message(p)
             write_cursor(d, a.agent, max_seq(d))
@@ -394,7 +448,24 @@ def cmd_wait(root: Path, a):
 
 def cmd_peek(root: Path, a):
     d = require_channel(root, a.channel)
-    files = message_files(d)[-a.n :]
+
+    if a.n <= 0:
+        return
+
+    # Optimization: Use a min-heap to find top N messages in O(N log K) time
+    # rather than sorting all messages O(N log N) via message_files()
+    top_n = []
+    for p in d.glob("*.md"):
+        seq = _seq_from_name(p.name)
+        if seq is not None:
+            if len(top_n) < a.n:
+                heapq.heappush(top_n, (seq, p))
+            elif seq > top_n[0][0]:
+                heapq.heapreplace(top_n, (seq, p))
+
+    # Extract in ascending order (heappop gets the smallest first)
+    files = [heapq.heappop(top_n)[1] for _ in range(len(top_n))]
+
     for p in files:
         _print_message(p)
     if not files:
@@ -409,13 +480,25 @@ def cmd_claim(root: Path, a):
     won the race -- exit non-zero so the caller moves on.
     """
     _check_safe_name(a.task, "task")
+    if not _TASK_MARKER_RE.fullmatch(a.task):
+        raise AgentChatError(
+            f"invalid task name (expected task-<id>.md marker): '{a.task}'"
+        )
     d = require_channel(root, a.channel)
     src = d / a.task
     dst = d / (Path(a.task).stem + f".CLAIMED-{slugify(a.agent)}.md")
+    lock = _acquire_lock(d)
     try:
-        os.replace(src, dst)  # atomic on Windows + POSIX when same directory
-    except FileNotFoundError:
-        die(f"task '{a.task}' already claimed or missing (lost the race)", code=3)
+        if dst.exists():
+            die(f"task '{a.task}' already claimed or missing (lost the race)", code=3)
+        if not src.is_file():
+            die(f"task '{a.task}' already claimed or missing (lost the race)", code=3)
+        try:
+            os.replace(src, dst)  # atomic on Windows + POSIX within the claim lock
+        except FileNotFoundError:
+            die(f"task '{a.task}' already claimed or missing (lost the race)", code=3)
+    finally:
+        _release_lock(lock)
     print(f"claimed {a.task} -> {dst.name}")
 
 
@@ -491,7 +574,13 @@ def build_parser() -> argparse.ArgumentParser:
 def main(argv=None):
     args = build_parser().parse_args(argv)
     root = root_dir(args.root)
-    args.func(root, args)
+    try:
+        args.func(root, args)
+    except AgentChatError as e:
+        die(str(e))
+    except KeyboardInterrupt:
+        print(file=sys.stderr)  # print a newline to cleanly break from input prompts
+        die("cancelled by user", code=130)
 
 
 if __name__ == "__main__":

{agent_chat_plugin-0.2.1 → agent_chat_plugin-0.3.0}/pyproject.toml

@@ -10,7 +10,7 @@ requires-python = ">=3.8"
 license = { text = "Apache-2.0" }
 authors = [{ name = "n24q02m" }]
 keywords = ["multi-agent", "coordination", "markdown", "blackboard", "claude-code", "agent-skills", "peer-to-peer"]
-version = "0.2.1"  # managed by python-semantic-release; do not hand-edit
+version = "0.3.0"  # managed by python-semantic-release; do not hand-edit
 classifiers = [
   "Programming Language :: Python :: 3",
   "License :: OSI Approved :: Apache Software License",

agent_chat_plugin-0.3.0/tests/test_chat.py

@@ -0,0 +1,324 @@
+"""Regression tests for the stdlib-only agent-chat CLI."""
+
+import contextlib
+import io
+import json
+import tempfile
+import unittest
+from pathlib import Path
+from types import SimpleNamespace
+from unittest.mock import patch
+
+import chat
+
+
+class _FakeStdin(io.StringIO):
+    def __init__(self, value, is_tty):
+        super().__init__(value)
+        self._is_tty = is_tty
+
+    def isatty(self):
+        return self._is_tty
+
+
+class ChatRegressionTests(unittest.TestCase):
+    def setUp(self):
+        self.temp_dir = tempfile.TemporaryDirectory()
+        self.root = Path(self.temp_dir.name)
+
+    def tearDown(self):
+        self.temp_dir.cleanup()
+
+    def _channel(self, name):
+        channel = self.root / name
+        channel.mkdir()
+        (channel / "_meta.json").write_text(
+            json.dumps({"channel": name, "members": [], "topic": ""}),
+            encoding="utf-8",
+        )
+        return channel
+
+    def _post_args(self, **overrides):
+        values = {
+            "channel": "general",
+            "sender": "alice",
+            "to": "bob",
+            "title": "Status update",
+            "reply": None,
+            "status": "discussion",
+            "body": "Message body",
+            "body_file": None,
+        }
+        values.update(overrides)
+        return SimpleNamespace(**values)
+
+    def test_post_title_newlines_cannot_forge_frontmatter_fields(self):
+        """A newline in a title must remain title content, never new metadata."""
+        channel = self._channel("general")
+        args = self._post_args(title="Status\nfrom: mallory\nto: eve")
+
+        with patch.object(chat, "now_iso", return_value="2026-08-09T00:00:00+00:00"):
+            with contextlib.redirect_stdout(io.StringIO()):
+                chat.cmd_post(self.root, args)
+
+        message = next(channel.glob("*.md"))
+        meta = chat.parse_frontmatter(message)
+        self.assertEqual(meta["from"], "alice")
+        self.assertEqual(meta["to"], "bob")
+        self.assertEqual(meta["title"], "Status from: mallory to: eve")
+
+    def test_max_seq_uses_highest_valid_sequence_with_gaps_and_malformed_files(self):
+        """Only numbered message filenames affect the maximum sequence."""
+        channel = self._channel("general")
+        for name in (
+            "0002-alice-first.md",
+            "0010-bob-last.md",
+            "broken.md",
+            "12x-nope.md",
+        ):
+            (channel / name).write_text("body", encoding="utf-8")
+
+        self.assertEqual(chat.max_seq(channel), 10)
+
+    def test_channels_reports_counts_and_last_message_for_empty_and_gapped_channels(
+        self,
+    ):
+        """Channel summaries count valid messages and select the highest sequence."""
+        alpha = self._channel("alpha")
+        self._channel("beta")
+        (alpha / "0002-alice-first.md").write_text(
+            "---\nfrom: alice\ntitle: First\n---\nbody\n", encoding="utf-8"
+        )
+        (alpha / "0010-bob-last.md").write_text(
+            "---\nfrom: bob\ntitle: Latest update\n---\nbody\n", encoding="utf-8"
+        )
+        (alpha / "not-a-message.md").write_text("ignored", encoding="utf-8")
+
+        output = io.StringIO()
+        with contextlib.redirect_stdout(output):
+            chat.cmd_channels(self.root, SimpleNamespace())
+
+        rendered = output.getvalue()
+        self.assertIn("alpha", rendered)
+        self.assertIn("   2", rendered)
+        self.assertIn("last: #10 bob: Latest update", rendered)
+        self.assertIn("beta", rendered)
+        self.assertIn("last: -", rendered)
+
+    def test_channels_marks_truncated_titles_with_ellipsis(self):
+        """Long channel titles retain an ASCII marker after truncation."""
+        channel = self._channel("general")
+        (channel / "0001-bob-long-title.md").write_text(
+            "---\nseq: 1\nfrom: bob\ntitle: " + ("A" * 41) + "\n---\nbody\n",
+            encoding="utf-8",
+        )
+
+        output = io.StringIO()
+        with contextlib.redirect_stdout(output):
+            chat.cmd_channels(self.root, SimpleNamespace())
+
+        self.assertIn("last: #1 bob: " + ("A" * 37) + "...", output.getvalue())
+
+    def test_channels_keeps_titles_at_the_display_limit(self):
+        """Titles at the 40-character limit are not shortened."""
+        channel = self._channel("general")
+        title = "B" * 40
+        (channel / "0001-bob-boundary.md").write_text(
+            f"---\nseq: 1\nfrom: bob\ntitle: {title}\n---\nbody\n",
+            encoding="utf-8",
+        )
+
+        output = io.StringIO()
+        with contextlib.redirect_stdout(output):
+            chat.cmd_channels(self.root, SimpleNamespace())
+
+        self.assertIn(f"last: #1 bob: {title}", output.getvalue())
+
+    def test_init_formats_member_list_for_cli_output(self):
+        """Init output uses a readable member list, not Python repr syntax."""
+        output = io.StringIO()
+        with contextlib.redirect_stdout(output):
+            chat.cmd_init(
+                self.root,
+                SimpleNamespace(channel="general", members="alice,bob", topic=None),
+            )
+
+        rendered = output.getvalue()
+        self.assertIn("members=alice, bob", rendered)
+        self.assertNotIn("members=['alice', 'bob']", rendered)
+
+    def test_main_maps_missing_body_file_to_application_error(self):
+        """A missing body file returns the CLI error contract, not a traceback."""
+        channel = self._channel("general")
+        missing = self.root / "missing.md"
+        stderr = io.StringIO()
+        with contextlib.redirect_stderr(stderr):
+            with self.assertRaises(SystemExit) as raised:
+                chat.main(
+                    [
+                        "--root",
+                        str(self.root),
+                        "post",
+                        "general",
+                        "--from",
+                        "alice",
+                        "--to",
+                        "bob",
+                        "--title",
+                        "Missing",
+                        "--body-file",
+                        str(missing),
+                    ]
+                )
+
+        self.assertEqual(raised.exception.code, 1)
+        self.assertIn("could not read body file", stderr.getvalue())
+        self.assertEqual(list(channel.glob("*.md")), [])
+
+    def test_main_maps_keyboard_interrupt_to_cancelled_exit(self):
+        """Ctrl-C is reported as a clean cancellation with exit code 130."""
+        stderr = io.StringIO()
+        with patch.object(chat, "cmd_init", side_effect=KeyboardInterrupt):
+            with contextlib.redirect_stderr(stderr):
+                with self.assertRaises(SystemExit) as raised:
+                    chat.main(["--root", str(self.root), "init", "cancelled"])
+
+        self.assertEqual(raised.exception.code, 130)
+        self.assertIn("cancelled by user", stderr.getvalue())
+
+    def test_init_rejects_reserved_channel_prefixes(self):
+        """User channels cannot collide with dotfiles or internal directories."""
+        for channel in ("_internal", ".hidden"):
+            with self.subTest(channel=channel), self.assertRaises(chat.AgentChatError):
+                chat.cmd_init(
+                    self.root,
+                    SimpleNamespace(channel=channel, members=None, topic=None),
+                )
+            self.assertFalse((self.root / channel).exists())
+
+    def test_read_preserves_sequence_order_and_advances_cursor(self):
+        """Unread messages are rendered in sequence order and advance the cursor."""
+        channel = self._channel("general")
+        (channel / "0002-bob-second.md").write_text(
+            "---\nseq: 2\nfrom: bob\nto: alice\ntitle: Second\n---\nbody\n",
+            encoding="utf-8",
+        )
+        (channel / "0001-bob-first.md").write_text(
+            "---\nseq: 1\nfrom: bob\nto: alice\ntitle: First\n---\nbody\n",
+            encoding="utf-8",
+        )
+
+        output = io.StringIO()
+        with contextlib.redirect_stdout(output):
+            chat.cmd_read(
+                self.root,
+                SimpleNamespace(
+                    channel="general", agent="alice", all=False, peek=False
+                ),
+            )
+
+        rendered = output.getvalue()
+        self.assertLess(rendered.index("title: First"), rendered.index("title: Second"))
+        self.assertEqual((channel / ".cursors" / "alice.txt").read_text(), "2")
+
+    def test_peek_zero_messages_is_empty(self):
+        """A zero-size peek must not index an empty heap."""
+        channel = self._channel("general")
+        (channel / "0001-bob-message.md").write_text(
+            "---\nseq: 1\nfrom: bob\ntitle: Message\n---\nbody\n",
+            encoding="utf-8",
+        )
+
+        output = io.StringIO()
+        with contextlib.redirect_stdout(output):
+            chat.cmd_peek(
+                self.root,
+                SimpleNamespace(channel="general", n=0),
+            )
+
+        self.assertEqual(output.getvalue(), "")
+
+    def test_claim_rejects_internal_channel_files(self):
+        """Claim must not rename channel metadata or cursor files."""
+        channel = self._channel("general")
+        args = SimpleNamespace(channel="general", task="_meta.json", agent="mallory")
+
+        with self.assertRaises(chat.AgentChatError):
+            chat.cmd_claim(self.root, args)
+
+        self.assertTrue((channel / "_meta.json").exists())
+
+    def test_claim_rejects_non_task_files(self):
+        """Claim accepts only the documented task marker filename shape."""
+        channel = self._channel("general")
+        for name in ("README.md", "0001-bob-message.md", "task-.md"):
+            path = channel / name
+            path.write_text("original", encoding="utf-8")
+            with self.subTest(name=name), self.assertRaises(chat.AgentChatError):
+                chat.cmd_claim(
+                    self.root,
+                    SimpleNamespace(channel="general", task=name, agent="mallory"),
+                )
+            self.assertTrue(path.exists())
+            self.assertEqual(path.read_text(encoding="utf-8"), "original")
+
+    def test_claim_renames_task_marker_without_overwriting_existing_claim(self):
+        """A destination collision is a lost claim, never an overwrite."""
+        channel = self._channel("general")
+        source = channel / "task-12.md"
+        claimed = channel / "task-12.CLAIMED-mallory.md"
+        source.write_text("task", encoding="utf-8")
+        claimed.write_text("other agent", encoding="utf-8")
+
+        with self.assertRaises(SystemExit) as raised:
+            chat.cmd_claim(
+                self.root,
+                SimpleNamespace(channel="general", task=source.name, agent="mallory"),
+            )
+
+        self.assertEqual(raised.exception.code, 3)
+        self.assertEqual(source.read_text(encoding="utf-8"), "task")
+        self.assertEqual(claimed.read_text(encoding="utf-8"), "other agent")
+
+    def test_claim_renames_valid_task_marker(self):
+        """A valid marker is renamed to the agent-specific claimed name."""
+        channel = self._channel("general")
+        source = channel / "task-12.md"
+        source.write_text("task", encoding="utf-8")
+
+        chat.cmd_claim(
+            self.root,
+            SimpleNamespace(channel="general", task=source.name, agent="alice"),
+        )
+
+        self.assertFalse(source.exists())
+        self.assertEqual(
+            (channel / "task-12.CLAIMED-alice.md").read_text(encoding="utf-8"),
+            "task",
+        )
+
+    def test_post_prompts_for_tty_stdin_but_not_piped_stdin(self):
+        """Interactive body entry gets guidance; a pipeline stays quiet."""
+        channel = self._channel("general")
+        tty_stderr = io.StringIO()
+        with patch.object(chat.sys, "stdin", _FakeStdin("typed body", True)):
+            with contextlib.redirect_stdout(io.StringIO()), contextlib.redirect_stderr(
+                tty_stderr
+            ):
+                chat.cmd_post(self.root, self._post_args(body=None))
+        self.assertIn("Enter message body", tty_stderr.getvalue())
+
+        pipe_stderr = io.StringIO()
+        with patch.object(chat.sys, "stdin", _FakeStdin("piped body", False)):
+            with contextlib.redirect_stdout(io.StringIO()), contextlib.redirect_stderr(
+                pipe_stderr
+            ):
+                chat.cmd_post(self.root, self._post_args(body=None, title="Piped"))
+        self.assertEqual(pipe_stderr.getvalue(), "")
+        self.assertIn(
+            "piped body", (channel / "0002-alice-piped.md").read_text(encoding="utf-8")
+        )
+
+
+if __name__ == "__main__":
+    unittest.main()

agent_chat_plugin-0.2.1/tests/test_chat.py

@@ -1,132 +0,0 @@
-"""Regression tests for the stdlib-only agent-chat CLI."""
-
-import contextlib
-import io
-import json
-import tempfile
-import unittest
-from pathlib import Path
-from types import SimpleNamespace
-from unittest.mock import patch
-
-import chat
-
-
-class _FakeStdin(io.StringIO):
-    def __init__(self, value, is_tty):
-        super().__init__(value)
-        self._is_tty = is_tty
-
-    def isatty(self):
-        return self._is_tty
-
-
-class ChatRegressionTests(unittest.TestCase):
-    def setUp(self):
-        self.temp_dir = tempfile.TemporaryDirectory()
-        self.root = Path(self.temp_dir.name)
-
-    def tearDown(self):
-        self.temp_dir.cleanup()
-
-    def _channel(self, name):
-        channel = self.root / name
-        channel.mkdir()
-        (channel / "_meta.json").write_text(
-            json.dumps({"channel": name, "members": [], "topic": ""}),
-            encoding="utf-8",
-        )
-        return channel
-
-    def _post_args(self, **overrides):
-        values = {
-            "channel": "general",
-            "sender": "alice",
-            "to": "bob",
-            "title": "Status update",
-            "reply": None,
-            "status": "discussion",
-            "body": "Message body",
-            "body_file": None,
-        }
-        values.update(overrides)
-        return SimpleNamespace(**values)
-
-    def test_post_title_newlines_cannot_forge_frontmatter_fields(self):
-        """A newline in a title must remain title content, never new metadata."""
-        channel = self._channel("general")
-        args = self._post_args(title="Status\nfrom: mallory\nto: eve")
-
-        with patch.object(chat, "now_iso", return_value="2026-08-09T00:00:00+00:00"):
-            with contextlib.redirect_stdout(io.StringIO()):
-                chat.cmd_post(self.root, args)
-
-        message = next(channel.glob("*.md"))
-        meta = chat.parse_frontmatter(message)
-        self.assertEqual(meta["from"], "alice")
-        self.assertEqual(meta["to"], "bob")
-        self.assertEqual(meta["title"], "Status from: mallory to: eve")
-
-    def test_max_seq_uses_highest_valid_sequence_with_gaps_and_malformed_files(self):
-        """Only numbered message filenames affect the maximum sequence."""
-        channel = self._channel("general")
-        for name in (
-            "0002-alice-first.md",
-            "0010-bob-last.md",
-            "broken.md",
-            "12x-nope.md",
-        ):
-            (channel / name).write_text("body", encoding="utf-8")
-
-        self.assertEqual(chat.max_seq(channel), 10)
-
-    def test_channels_reports_counts_and_last_message_for_empty_and_gapped_channels(
-        self,
-    ):
-        """Channel summaries count valid messages and select the highest sequence."""
-        alpha = self._channel("alpha")
-        self._channel("beta")
-        (alpha / "0002-alice-first.md").write_text(
-            "---\nfrom: alice\ntitle: First\n---\nbody\n", encoding="utf-8"
-        )
-        (alpha / "0010-bob-last.md").write_text(
-            "---\nfrom: bob\ntitle: Latest update\n---\nbody\n", encoding="utf-8"
-        )
-        (alpha / "not-a-message.md").write_text("ignored", encoding="utf-8")
-
-        output = io.StringIO()
-        with contextlib.redirect_stdout(output):
-            chat.cmd_channels(self.root, SimpleNamespace())
-
-        rendered = output.getvalue()
-        self.assertIn("alpha", rendered)
-        self.assertIn("   2", rendered)
-        self.assertIn("last: #10 bob: Latest update", rendered)
-        self.assertIn("beta", rendered)
-        self.assertIn("last: -", rendered)
-
-    def test_post_prompts_for_tty_stdin_but_not_piped_stdin(self):
-        """Interactive body entry gets guidance; a pipeline stays quiet."""
-        channel = self._channel("general")
-        tty_stderr = io.StringIO()
-        with patch.object(chat.sys, "stdin", _FakeStdin("typed body", True)):
-            with contextlib.redirect_stdout(io.StringIO()), contextlib.redirect_stderr(
-                tty_stderr
-            ):
-                chat.cmd_post(self.root, self._post_args(body=None))
-        self.assertIn("Enter message body", tty_stderr.getvalue())
-
-        pipe_stderr = io.StringIO()
-        with patch.object(chat.sys, "stdin", _FakeStdin("piped body", False)):
-            with contextlib.redirect_stdout(io.StringIO()), contextlib.redirect_stderr(
-                pipe_stderr
-            ):
-                chat.cmd_post(self.root, self._post_args(body=None, title="Piped"))
-        self.assertEqual(pipe_stderr.getvalue(), "")
-        self.assertIn(
-            "piped body", (channel / "0002-alice-piped.md").read_text(encoding="utf-8")
-        )
-
-
-if __name__ == "__main__":
-    unittest.main()