agentirc-cli 0.18.0__tar.gz → 0.20.0__tar.gz

agentirc_cli-0.20.0/.flake8

@@ -0,0 +1,19 @@
+[flake8]
+max-line-length = 100
+exclude =
+    .git,
+    __pycache__,
+    .venv,
+    dist,
+    build,
+    .eggs,
+    packages
+extend-ignore =
+    E203,
+    W503,
+    S101
+per-file-ignores =
+    agentirc/credentials.py:S603,S607
+    agentirc/persistence.py:S603,S607
+    agentirc/cli.py:S603,S607
+    tests/*:S101

agentirc_cli-0.20.0/.github/workflows/security-checks.yml

@@ -0,0 +1,99 @@
+name: Security Checks
+
+on:
+  push:
+    branches: [main]
+  pull_request:
+    branches: [main]
+  schedule:
+    - cron: '0 0 * * 0'  # Weekly on Sunday at midnight
+  workflow_dispatch:
+
+permissions:
+  contents: read
+
+jobs:
+  security-scans:
+    name: Security Scans
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v4
+        with:
+          fetch-depth: 0
+
+      - uses: astral-sh/setup-uv@v4
+
+      - run: uv python install 3.12
+
+      - run: uv sync
+
+      - name: Run Bandit
+        run: uv run bandit -r agentirc/ -f json -o bandit-results.json -c pyproject.toml
+        continue-on-error: true
+
+      - name: Run Pylint
+        run: uv run pylint agentirc/ --rcfile=.pylintrc --output-format=json:pylint-results.json,text
+        continue-on-error: true
+
+      - name: Run Safety dependency check
+        run: uv run safety check --full-report --output json > safety-results.json
+        continue-on-error: true
+
+      - name: Upload Security Results
+        uses: actions/upload-artifact@v4
+        with:
+          name: security-results
+          path: |
+            bandit-results.json
+            pylint-results.json
+            safety-results.json
+
+      - name: Run test coverage
+        run: |
+          uv run pytest --cov=agentirc --cov-report=xml:coverage.xml --cov-report=term -v
+        continue-on-error: true
+
+      - name: SonarCloud Scan
+        uses: SonarSource/sonarqube-scan-action@v7
+        env:
+          GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
+          SONAR_TOKEN: ${{ secrets.SONAR_TOKEN }}
+        with:
+          args: >
+            -Dsonar.projectKey=OriNachum_AgentIRC
+            -Dsonar.organization=${{ github.repository_owner }}
+            -Dsonar.python.coverage.reportPaths=coverage.xml
+            -Dsonar.python.bandit.reportPaths=bandit-results.json
+            -Dsonar.python.pylint.reportPaths=pylint-results.json
+
+  dependency-review:
+    name: Dependency Review
+    if: github.event_name == 'pull_request'
+    runs-on: ubuntu-latest
+    permissions:
+      contents: read
+      pull-requests: write
+    steps:
+      - uses: actions/checkout@v4
+
+      - name: Dependency Review
+        uses: actions/dependency-review-action@v4
+        with:
+          fail-on-severity: high
+
+  codeql-analysis:
+    name: CodeQL Analysis
+    runs-on: ubuntu-latest
+    permissions:
+      contents: read
+      security-events: write
+    steps:
+      - uses: actions/checkout@v4
+
+      - name: Initialize CodeQL
+        uses: github/codeql-action/init@v3
+        with:
+          languages: python
+
+      - name: Perform CodeQL Analysis
+        uses: github/codeql-action/analyze@v3

{agentirc_cli-0.18.0 → agentirc_cli-0.20.0}/.gitignore

@@ -206,6 +206,12 @@ marimo/_static/
 marimo/_lsp/
 __marimo__/
 
+# Security scan reports
+bandit-results.json
+pylint-results.json
+safety-results.json
+.sonar/
+
 # Superpowers & worktrees
 .superpowers/
 .worktrees/

agentirc_cli-0.20.0/.pre-commit-config.yaml

@@ -0,0 +1,42 @@
+repos:
+- repo: https://github.com/pre-commit/pre-commit-hooks
+  rev: v4.4.0
+  hooks:
+  - id: trailing-whitespace
+  - id: end-of-file-fixer
+  - id: check-yaml
+  - id: check-added-large-files
+  - id: check-ast
+  - id: detect-private-key
+
+- repo: local
+  hooks:
+  - id: flake8
+    name: flake8
+    entry: uv run flake8 --config=.flake8
+    language: system
+    types: [python]
+
+  - id: isort
+    name: isort
+    entry: uv run isort
+    language: system
+    types: [python]
+
+  - id: black
+    name: black
+    entry: uv run black
+    language: system
+    types: [python]
+
+  - id: bandit
+    name: bandit
+    entry: uv run bandit -c pyproject.toml
+    language: system
+    types: [python]
+
+  - id: pylint
+    name: pylint
+    entry: uv run pylint --rcfile=.pylintrc
+    language: system
+    types: [python]

agentirc_cli-0.20.0/.pylintrc

@@ -0,0 +1,77 @@
+[MASTER]
+ignore=CVS
+persistent=yes
+load-plugins=
+
+[MESSAGES CONTROL]
+disable=
+    C0114,  # missing-module-docstring
+    C0115,  # missing-class-docstring
+    C0116,  # missing-function-docstring
+    C0301,  # line-too-long (handled by black)
+    C0303,  # trailing-whitespace
+    R0801,  # duplicate-code (assimilai pattern: backends share identical files)
+    R0903,  # too-few-public-methods
+    R0913,  # too-many-arguments
+    W0511,  # fixme
+    W0718,  # broad-exception-caught (async server/daemon must catch broadly)
+    W0719,  # broad-exception-raised
+    W1202,  # logging-format-interpolation
+    W1203,  # logging-fstring-interpolation
+
+[REPORTS]
+output-format=text
+reports=yes
+evaluation=10.0 - ((float(5 * error + warning + refactor + convention) / statement) * 10)
+
+[VARIABLES]
+init-import=no
+dummy-variables-rgx=_$|dummy
+
+[FORMAT]
+max-line-length=100
+ignore-long-lines=^\s*(# )?<?https?://\S+>?$
+single-line-if-stmt=no
+indent-string='    '
+max-module-lines=1000
+
+[SIMILARITIES]
+min-similarity-lines=8
+ignore-comments=yes
+ignore-docstrings=yes
+ignore-imports=yes
+
+[BASIC]
+good-names=i,j,k,ex,Run,_,e,f,fd,ws,ts,ok,ch,ip,op
+bad-names=foo,bar,baz,toto,tutu,tata
+function-rgx=[a-z_][a-z0-9_]{2,50}$
+variable-rgx=[a-z_][a-z0-9_]{1,30}$
+const-rgx=(([A-Z_][A-Z0-9_]*)|(__.*__))$
+attr-rgx=[a-z_][a-z0-9_]{1,30}$
+argument-rgx=[a-z_][a-z0-9_]{1,30}$
+class-rgx=[A-Z_][a-zA-Z0-9]+$
+inlinevar-rgx=[A-Za-z_][A-Za-z0-9_]*$
+no-docstring-rgx=^_
+
+[DESIGN]
+max-args=10
+ignored-argument-names=_.*
+max-locals=15
+max-returns=6
+max-branches=12
+max-statements=50
+max-parents=7
+max-attributes=15
+min-public-methods=2
+max-public-methods=20
+
+[CLASSES]
+defining-attr-methods=__init__,__new__,setUp
+valid-classmethod-first-arg=cls
+valid-metaclass-classmethod-first-arg=mcs
+
+[IMPORTS]
+deprecated-modules=regsub,TERMIOS,Bastion,rexec
+
+[EXCEPTIONS]
+overgeneral-exceptions=builtins.BaseException

{agentirc_cli-0.18.0 → agentirc_cli-0.20.0}/CHANGELOG.md

@@ -4,11 +4,46 @@ All notable changes to this project will be documented in this file.
 
 Format follows [Keep a Changelog](https://keepachangelog.com/).
 
-## [0.18.0] - 2026-04-02
+## [0.20.0] - 2026-04-03
 
 
 ### Added
 
+- Bandit SAST security scanning
+- Pylint static code analysis
+- Safety dependency vulnerability scanning
+- CodeQL semantic analysis (GitHub-native)
+- SonarCloud code quality and security integration
+- Pre-commit hooks (flake8+bandit+bugbear, isort, black, pylint, detect-private-key)
+- Security CI workflow (security-checks.yml)
+- Dependency Review on PRs (fails on high severity)
+- SECURITY.md vulnerability disclosure policy
+- docs/SECURITY.md contributor security guidelines
+- Code coverage enforcement in CI
+
+## [0.19.0] - 2026-04-03
+
+
+### Added
+
+- Conversation threads — inline sub-conversations with [thread:name] prefix
+- Breakout channel promotion from threads
+- Thread-scoped agent context on @mention
+- S2S federation for thread messages
+- JSON persistence for threads across restarts
+- Thread support in all 4 agent backends (claude, codex, copilot, acp)
+
+## [0.18.0] - 2026-04-03
+
+
+### Added
+
+- Conversation threads — inline sub-conversations with [thread:name] prefix
+- Breakout channel promotion from threads
+- Thread-scoped agent context on @mention
+- S2S federation for thread messages
+- JSON persistence for threads across restarts
+- Thread support in all 4 agent backends (claude, codex, copilot, acp)
 - S2S link auto-reconnect with exponential backoff (5s to 120s)
 - Declarative mesh.yaml configuration for multi-machine setup
 - Cross-platform auto-start persistence (systemd, launchd, Windows schtasks)

{agentirc_cli-0.18.0 → agentirc_cli-0.20.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: agentirc-cli
-Version: 0.18.0
+Version: 0.20.0
 Summary: 🌱 The space your agents deserve — an autonomous agent mesh where AI agents live, collaborate, and grow
 Project-URL: Homepage, https://github.com/OriNachum/agentirc
 Author: Ori Nachum

agentirc_cli-0.20.0/SECURITY.md

@@ -0,0 +1,39 @@
+# Security Policy
+
+## Reporting a Vulnerability
+
+If you discover a security vulnerability in AgentIRC, please report it responsibly.
+
+**Do not** open a public GitHub issue for security vulnerabilities.
+
+### How to Report
+
+Please report security issues privately using one of the following methods:
+
+- **GitHub Security Advisories**: [Report a vulnerability privately](../../security/advisories/new)
+- **Email**: Contact the maintainer directly
+
+Include:
+
+- A description of the vulnerability
+- Steps to reproduce the issue
+- The potential impact
+
+### Response Timeline
+
+- **Acknowledgment**: Within 48 hours
+- **Fix timeline**: Within 7 days of acknowledgment
+- **Disclosure**: Coordinated with the reporter after a fix is available
+
+## Security Measures
+
+This project uses automated security scanning:
+
+- **Bandit** — Python security vulnerability detection
+- **Pylint** — Static code analysis
+- **CodeQL** — GitHub-native semantic analysis
+- **SonarCloud** — Comprehensive code quality and security
+- **Safety** — Dependency vulnerability scanning
+- **Dependency Review** — PR-level dependency checks
+
+See [docs/SECURITY.md](docs/SECURITY.md) for full details on the security toolchain and contributor guidelines.

{agentirc_cli-0.18.0 → agentirc_cli-0.20.0}/agentirc/clients/acp/daemon.py

@@ -273,7 +273,7 @@ class ACPDaemon:
     def _on_mention(self, target: str, sender: str, text: str) -> None:
         """Called by IRCTransport when the agent is @mentioned or DM'd.
 
-        Formats a prompt and enqueues it so the ACP session picks it up.
+        When the mention is inside a thread, provides thread-scoped context.
         """
         if self._paused:
             return
@@ -282,7 +282,21 @@ class ACPDaemon:
             # Enqueue relay target (FIFO matches prompt queue order)
             self._mention_targets.append(target if target.startswith("#") else sender)
             if target.startswith("#"):
-                prompt = f"[IRC @mention in {target}] <{sender}> {text}"
+                import re
+                thread_match = re.match(r"^\[thread:([a-zA-Z0-9\-]+)\] ", text)
+                if thread_match and self._buffer:
+                    thread_name = thread_match.group(1)
+                    thread_msgs = self._buffer.read_thread(target, thread_name)
+                    history = "\n".join(
+                        f"  <{m.nick}> {m.text}" for m in thread_msgs
+                    )
+                    prompt = (
+                        f"[IRC @mention in {target}, thread:{thread_name}]\n"
+                        f"Thread history:\n{history}\n"
+                        f"  <{sender}> {text}"
+                    )
+                else:
+                    prompt = f"[IRC @mention in {target}] <{sender}> {text}"
             else:
                 prompt = f"[IRC DM] <{sender}> {text}"
             asyncio.create_task(self._agent_runner.send_prompt(prompt))
@@ -510,6 +524,21 @@ class ACPDaemon:
             elif msg_type == "resume":
                 return await self._ipc_resume(req_id)
 
+            elif msg_type == "irc_thread_create":
+                return await self._ipc_irc_thread_create(req_id, msg)
+
+            elif msg_type == "irc_thread_reply":
+                return await self._ipc_irc_thread_reply(req_id, msg)
+
+            elif msg_type == "irc_threads":
+                return await self._ipc_irc_threads(req_id, msg)
+
+            elif msg_type == "irc_thread_close":
+                return await self._ipc_irc_thread_close(req_id, msg)
+
+            elif msg_type == "irc_thread_read":
+                return await self._ipc_irc_thread_read(req_id, msg)
+
             elif msg_type == "shutdown":
                 asyncio.create_task(self._graceful_shutdown())
                 return make_response(req_id, ok=True)
@@ -642,6 +671,64 @@ class ACPDaemon:
         await self._transport.part_channel(channel)
         return make_response(req_id, ok=True)
 
+    async def _ipc_irc_thread_create(self, req_id: str, msg: dict) -> dict:
+        channel = msg.get("channel", "")
+        thread_name = msg.get("thread", "")
+        text = msg.get("message", "")
+        if not channel or not thread_name or not text:
+            return make_response(req_id, ok=False,
+                                 error="Missing 'channel', 'thread', or 'message'")
+        assert self._transport is not None
+        await self._transport.send_thread_create(channel, thread_name, text)
+        return make_response(req_id, ok=True)
+
+    async def _ipc_irc_thread_reply(self, req_id: str, msg: dict) -> dict:
+        channel = msg.get("channel", "")
+        thread_name = msg.get("thread", "")
+        text = msg.get("message", "")
+        if not channel or not thread_name or not text:
+            return make_response(req_id, ok=False,
+                                 error="Missing 'channel', 'thread', or 'message'")
+        assert self._transport is not None
+        await self._transport.send_thread_reply(channel, thread_name, text)
+        return make_response(req_id, ok=True)
+
+    async def _ipc_irc_threads(self, req_id: str, msg: dict) -> dict:
+        channel = msg.get("channel", "")
+        if not channel:
+            return make_response(req_id, ok=False, error="Missing 'channel'")
+        assert self._transport is not None
+        await self._transport.send_threads_list(channel)
+        return make_response(req_id, ok=True)
+
+    async def _ipc_irc_thread_close(self, req_id: str, msg: dict) -> dict:
+        channel = msg.get("channel", "")
+        thread_name = msg.get("thread", "")
+        summary = msg.get("summary", "")
+        if not channel or not thread_name:
+            return make_response(req_id, ok=False,
+                                 error="Missing 'channel' or 'thread'")
+        assert self._transport is not None
+        await self._transport.send_thread_close(channel, thread_name, summary)
+        return make_response(req_id, ok=True)
+
+    async def _ipc_irc_thread_read(self, req_id: str, msg: dict) -> dict:
+        channel = msg.get("channel", "")
+        thread_name = msg.get("thread", "")
+        limit = int(msg.get("limit", 50))
+        if not channel or not thread_name:
+            return make_response(req_id, ok=False,
+                                 error="Missing 'channel' or 'thread'")
+        assert self._buffer is not None
+        messages = self._buffer.read_thread(channel, thread_name, limit=limit)
+        return make_response(req_id, ok=True, data={
+            "messages": [
+                {"nick": m.nick, "text": m.text, "timestamp": m.timestamp,
+                 "thread": m.thread}
+                for m in messages
+            ]
+        })
+
     async def _ipc_irc_channels(self, req_id: str) -> dict:
         assert self._transport is not None
         return make_response(req_id, ok=True, data={"channels": self._transport.channels})

{agentirc_cli-0.18.0 → agentirc_cli-0.20.0}/agentirc/clients/acp/irc_transport.py

@@ -73,6 +73,18 @@ class IRCTransport:
     async def send_privmsg(self, target: str, text: str) -> None:
         await self._send_raw(f"PRIVMSG {target} :{text}")
 
+    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}")
+
+    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}")
+
+    async def send_thread_close(self, channel: str, thread_name: str, summary: str) -> None:
+        await self._send_raw(f"THREADCLOSE {channel} {thread_name} :{summary}")
+
+    async def send_threads_list(self, channel: str) -> None:
+        await self._send_raw(f"THREADS {channel}")
+
     async def join_channel(self, channel: str) -> None:
         await self._send_raw(f"JOIN {channel}")
         if channel not in self.channels:

{agentirc_cli-0.18.0 → agentirc_cli-0.20.0}/agentirc/clients/acp/message_buffer.py

@@ -1,15 +1,19 @@
 from __future__ import annotations
 
+import re
 import time
 from collections import deque
 from dataclasses import dataclass, field
 
+_THREAD_PREFIX_RE = re.compile(r"^\[thread:([a-zA-Z0-9\-]+)\] ")
+
 
 @dataclass
 class BufferedMessage:
     nick: str
     text: str
     timestamp: float
+    thread: str | None = None
 
 
 class MessageBuffer:
@@ -24,8 +28,13 @@ class MessageBuffer:
             self._buffers[channel] = deque(maxlen=self.max_per_channel)
             self._totals[channel] = 0
             self._cursors[channel] = 0
+        thread = None
+        m = _THREAD_PREFIX_RE.match(text)
+        if m:
+            thread = m.group(1)
         self._buffers[channel].append(
-            BufferedMessage(nick=nick, text=text, timestamp=time.time())
+            BufferedMessage(nick=nick, text=text, timestamp=time.time(),
+                           thread=thread)
         )
         self._totals[channel] += 1
 
@@ -44,3 +53,13 @@ class MessageBuffer:
             new_messages = new_messages[-limit:]
         self._cursors[channel] = total
         return new_messages
+
+    def read_thread(self, channel: str, thread_name: str,
+                    limit: int = 50) -> list[BufferedMessage]:
+        buf = self._buffers.get(channel)
+        if not buf:
+            return []
+        matches = [m for m in buf if m.thread == thread_name]
+        if len(matches) > limit:
+            matches = matches[-limit:]
+        return matches

{agentirc_cli-0.18.0 → agentirc_cli-0.20.0}/agentirc/clients/claude/daemon.py

@@ -239,14 +239,28 @@ class AgentDaemon:
     def _on_mention(self, target: str, sender: str, text: str) -> None:
         """Called by IRCTransport when the agent is @mentioned or DM'd.
 
-        Formats a prompt and enqueues it so the SDK session picks it up.
+        When the mention is inside a thread, provides thread-scoped context.
         """
         if self._paused:
             return
         if self._agent_runner and self._agent_runner.is_running():
             self._last_activation = time.time()
             if target.startswith("#"):
-                prompt = f"[IRC @mention in {target}] <{sender}> {text}"
+                import re
+                thread_match = re.match(r"^\[thread:([a-zA-Z0-9\-]+)\] ", text)
+                if thread_match and self._buffer:
+                    thread_name = thread_match.group(1)
+                    thread_msgs = self._buffer.read_thread(target, thread_name)
+                    history = "\n".join(
+                        f"  <{m.nick}> {m.text}" for m in thread_msgs
+                    )
+                    prompt = (
+                        f"[IRC @mention in {target}, thread:{thread_name}]\n"
+                        f"Thread history:\n{history}\n"
+                        f"  <{sender}> {text}"
+                    )
+                else:
+                    prompt = f"[IRC @mention in {target}] <{sender}> {text}"
             else:
                 prompt = f"[IRC DM] <{sender}> {text}"
             asyncio.create_task(self._agent_runner.send_prompt(prompt))
@@ -451,6 +465,21 @@ class AgentDaemon:
             elif msg_type == "resume":
                 return await self._ipc_resume(req_id)
 
+            elif msg_type == "irc_thread_create":
+                return await self._ipc_irc_thread_create(req_id, msg)
+
+            elif msg_type == "irc_thread_reply":
+                return await self._ipc_irc_thread_reply(req_id, msg)
+
+            elif msg_type == "irc_threads":
+                return await self._ipc_irc_threads(req_id, msg)
+
+            elif msg_type == "irc_thread_close":
+                return await self._ipc_irc_thread_close(req_id, msg)
+
+            elif msg_type == "irc_thread_read":
+                return await self._ipc_irc_thread_read(req_id, msg)
+
             elif msg_type == "shutdown":
                 asyncio.create_task(self._graceful_shutdown())
                 return make_response(req_id, ok=True)
@@ -580,6 +609,64 @@ class AgentDaemon:
         await self._transport.part_channel(channel)
         return make_response(req_id, ok=True)
 
+    async def _ipc_irc_thread_create(self, req_id: str, msg: dict) -> dict:
+        channel = msg.get("channel", "")
+        thread_name = msg.get("thread", "")
+        text = msg.get("message", "")
+        if not channel or not thread_name or not text:
+            return make_response(req_id, ok=False,
+                                 error="Missing 'channel', 'thread', or 'message'")
+        assert self._transport is not None
+        await self._transport.send_thread_create(channel, thread_name, text)
+        return make_response(req_id, ok=True)
+
+    async def _ipc_irc_thread_reply(self, req_id: str, msg: dict) -> dict:
+        channel = msg.get("channel", "")
+        thread_name = msg.get("thread", "")
+        text = msg.get("message", "")
+        if not channel or not thread_name or not text:
+            return make_response(req_id, ok=False,
+                                 error="Missing 'channel', 'thread', or 'message'")
+        assert self._transport is not None
+        await self._transport.send_thread_reply(channel, thread_name, text)
+        return make_response(req_id, ok=True)
+
+    async def _ipc_irc_threads(self, req_id: str, msg: dict) -> dict:
+        channel = msg.get("channel", "")
+        if not channel:
+            return make_response(req_id, ok=False, error="Missing 'channel'")
+        assert self._transport is not None
+        await self._transport.send_threads_list(channel)
+        return make_response(req_id, ok=True)
+
+    async def _ipc_irc_thread_close(self, req_id: str, msg: dict) -> dict:
+        channel = msg.get("channel", "")
+        thread_name = msg.get("thread", "")
+        summary = msg.get("summary", "")
+        if not channel or not thread_name:
+            return make_response(req_id, ok=False,
+                                 error="Missing 'channel' or 'thread'")
+        assert self._transport is not None
+        await self._transport.send_thread_close(channel, thread_name, summary)
+        return make_response(req_id, ok=True)
+
+    async def _ipc_irc_thread_read(self, req_id: str, msg: dict) -> dict:
+        channel = msg.get("channel", "")
+        thread_name = msg.get("thread", "")
+        limit = int(msg.get("limit", 50))
+        if not channel or not thread_name:
+            return make_response(req_id, ok=False,
+                                 error="Missing 'channel' or 'thread'")
+        assert self._buffer is not None
+        messages = self._buffer.read_thread(channel, thread_name, limit=limit)
+        return make_response(req_id, ok=True, data={
+            "messages": [
+                {"nick": m.nick, "text": m.text, "timestamp": m.timestamp,
+                 "thread": m.thread}
+                for m in messages
+            ]
+        })
+
     async def _ipc_irc_channels(self, req_id: str) -> dict:
         assert self._transport is not None
         return make_response(req_id, ok=True, data={"channels": self._transport.channels})

{agentirc_cli-0.18.0 → agentirc_cli-0.20.0}/agentirc/clients/claude/irc_transport.py

@@ -73,6 +73,18 @@ class IRCTransport:
     async def send_privmsg(self, target: str, text: str) -> None:
         await self._send_raw(f"PRIVMSG {target} :{text}")
 
+    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}")
+
+    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}")
+
+    async def send_thread_close(self, channel: str, thread_name: str, summary: str) -> None:
+        await self._send_raw(f"THREADCLOSE {channel} {thread_name} :{summary}")
+
+    async def send_threads_list(self, channel: str) -> None:
+        await self._send_raw(f"THREADS {channel}")
+
     async def join_channel(self, channel: str) -> None:
         await self._send_raw(f"JOIN {channel}")
         if channel not in self.channels: