devcopilot 0.2.0__py3-none-any.whl

messaging/trees/repository.py

@@ -0,0 +1,177 @@
+"""In-memory repository for messaging trees and node indexes."""
+
+from loguru import logger
+
+from .data import MessageNode, MessageState, MessageTree
+
+
+class TreeRepository:
+    """
+    In-memory index of trees and node-to-root mappings.
+
+    Used only by TreeQueueManager; kept as a named type for focused tests.
+    """
+
+    def __init__(self) -> None:
+        self._trees: dict[str, MessageTree] = {}
+        self._node_to_tree: dict[str, str] = {}
+
+    def get_tree(self, root_id: str) -> MessageTree | None:
+        """Get a tree by its root ID."""
+        return self._trees.get(root_id)
+
+    def get_tree_for_node(self, node_id: str) -> MessageTree | None:
+        """Get the tree containing a given node."""
+        root_id = self._node_to_tree.get(node_id)
+        if not root_id:
+            return None
+        return self._trees.get(root_id)
+
+    def get_node(self, node_id: str) -> MessageNode | None:
+        """Get a node from any tree."""
+        tree = self.get_tree_for_node(node_id)
+        return tree.get_node(node_id) if tree else None
+
+    def add_tree(self, root_id: str, tree: MessageTree) -> None:
+        """Add a new tree to the repository."""
+        self._trees[root_id] = tree
+        self._node_to_tree[root_id] = root_id
+        logger.debug("TREE_REPO: add_tree root_id={}", root_id)
+
+    def register_node(self, node_id: str, root_id: str) -> None:
+        """Register a node ID to a tree."""
+        self._node_to_tree[node_id] = root_id
+        logger.debug("TREE_REPO: register_node node_id={} root_id={}", node_id, root_id)
+
+    def has_node(self, node_id: str) -> bool:
+        """Check if a node is registered in any tree."""
+        return node_id in self._node_to_tree
+
+    def tree_count(self) -> int:
+        """Get the number of trees in the repository."""
+        return len(self._trees)
+
+    def is_tree_busy(self, root_id: str) -> bool:
+        """Check if a tree is currently processing."""
+        tree = self._trees.get(root_id)
+        return tree.is_processing if tree else False
+
+    def is_node_tree_busy(self, node_id: str) -> bool:
+        """Check if the tree containing a node is busy."""
+        tree = self.get_tree_for_node(node_id)
+        return tree.is_processing if tree else False
+
+    def get_queue_size(self, node_id: str) -> int:
+        """Get queue size for the tree containing a node."""
+        tree = self.get_tree_for_node(node_id)
+        return tree.get_queue_size() if tree else 0
+
+    def resolve_parent_node_id(self, msg_id: str) -> str | None:
+        """
+        Resolve a message ID to the actual parent node ID.
+
+        Handles the case where msg_id is a status message ID
+        (which maps to the tree but isn't an actual node).
+        """
+        tree = self.get_tree_for_node(msg_id)
+        if not tree:
+            return None
+
+        if tree.has_node(msg_id):
+            return msg_id
+
+        node = tree.find_node_by_status_message(msg_id)
+        if node:
+            return node.node_id
+
+        return None
+
+    def get_pending_children(self, node_id: str) -> list[MessageNode]:
+        """Get all pending child nodes recursively for error propagation."""
+        tree = self.get_tree_for_node(node_id)
+        if not tree:
+            return []
+
+        pending: list[MessageNode] = []
+        stack = [node_id]
+
+        while stack:
+            current_id = stack.pop()
+            node = tree.get_node(current_id)
+            if not node:
+                continue
+            for child_id in node.children_ids:
+                child = tree.get_node(child_id)
+                if child and child.state == MessageState.PENDING:
+                    pending.append(child)
+                    stack.append(child_id)
+
+        return pending
+
+    def all_trees(self) -> list[MessageTree]:
+        """Get all trees in the repository."""
+        return list(self._trees.values())
+
+    def tree_ids(self) -> list[str]:
+        """Get all tree root IDs."""
+        return list(self._trees.keys())
+
+    def unregister_nodes(self, node_ids: list[str]) -> None:
+        """Remove lookup IDs from the node-to-tree mapping."""
+        for nid in node_ids:
+            self._node_to_tree.pop(nid, None)
+
+    def unregister_node_lookups(self, nodes: list[MessageNode]) -> None:
+        """Remove node and status-message lookup IDs for removed nodes."""
+        lookup_ids: list[str] = []
+        for node in nodes:
+            lookup_ids.append(node.node_id)
+            if node.status_message_id:
+                lookup_ids.append(node.status_message_id)
+        self.unregister_nodes(lookup_ids)
+
+    def remove_tree(self, root_id: str) -> MessageTree | None:
+        """
+        Remove a tree and all its node mappings from the repository.
+
+        Returns the removed tree, or None if not found.
+        """
+        tree = self._trees.pop(root_id, None)
+        if not tree:
+            return None
+        self.unregister_node_lookups(tree.all_nodes())
+        logger.debug("TREE_REPO: remove_tree root_id={}", root_id)
+        return tree
+
+    def get_message_ids_for_chat(self, platform: str, chat_id: str) -> set[str]:
+        """Get all message IDs (incoming + status) for a platform/chat."""
+        msg_ids: set[str] = set()
+        for tree in self._trees.values():
+            for node in tree.all_nodes():
+                if str(node.incoming.platform) == str(platform) and str(
+                    node.incoming.chat_id
+                ) == str(chat_id):
+                    if node.incoming.message_id is not None:
+                        msg_ids.add(str(node.incoming.message_id))
+                    if node.status_message_id:
+                        msg_ids.add(str(node.status_message_id))
+        return msg_ids
+
+    def to_dict(self) -> dict:
+        """Serialize all trees."""
+        return {
+            "trees": {rid: tree.to_dict() for rid, tree in self._trees.items()},
+            "node_to_tree": self._node_to_tree.copy(),
+        }
+
+    @classmethod
+    def from_dict(cls, data: dict) -> TreeRepository:
+        """Deserialize from dictionary."""
+        repo = cls()
+        for root_id, tree_data in data.get("trees", {}).items():
+            repo._trees[root_id] = MessageTree.from_dict(tree_data)
+        repo._node_to_tree = data.get("node_to_tree", {})
+        return repo
+
+
+__all__ = ["TreeRepository"]

messaging/turn_intake.py

@@ -0,0 +1,235 @@
+"""Inbound messaging turn intake and queue admission."""
+
+from __future__ import annotations
+
+from collections.abc import Awaitable, Callable
+
+from loguru import logger
+
+from core.trace import trace_event
+
+from .cli_event_constants import STATUS_MESSAGE_PREFIXES
+from .command_context import MessagingCommandContext
+from .command_dispatcher import (
+    dispatch_command,
+    message_kind_for_command,
+    parse_command_base,
+)
+from .models import IncomingMessage
+from .platforms.base import MessagingPlatform
+from .safe_diagnostics import format_exception_for_log
+from .session import SessionStore
+from .trees import MessageNode, MessageState, MessageTree, TreeQueueManager
+
+
+class MessagingTurnIntake:
+    """Owns inbound turn classification and queue admission."""
+
+    def __init__(
+        self,
+        *,
+        platform: MessagingPlatform,
+        session_store: SessionStore,
+        command_context: MessagingCommandContext,
+        get_tree_queue: Callable[[], TreeQueueManager],
+        process_node: Callable[[str, MessageNode], Awaitable[None]],
+        format_status: Callable[[str, str, str | None], str],
+        get_parse_mode: Callable[[], str | None],
+        record_outgoing_message: Callable[[str, str, str | None, str], None],
+        log_messaging_error_details: bool = False,
+    ) -> None:
+        self.platform = platform
+        self.session_store = session_store
+        self._command_context = command_context
+        self._get_tree_queue = get_tree_queue
+        self._process_node = process_node
+        self._format_status = format_status
+        self._get_parse_mode = get_parse_mode
+        self._record_outgoing_message = record_outgoing_message
+        self._log_messaging_error_details = log_messaging_error_details
+
+    async def handle_message(self, incoming: IncomingMessage) -> None:
+        """
+        Handle an inbound platform message and queue it if it is a user prompt.
+        """
+        cmd_base = parse_command_base(incoming.text)
+
+        try:
+            if incoming.message_id is not None:
+                self.session_store.record_message_id(
+                    incoming.platform,
+                    incoming.chat_id,
+                    str(incoming.message_id),
+                    direction="in",
+                    kind=message_kind_for_command(cmd_base),
+                )
+        except Exception as e:
+            logger.debug(
+                "Failed to record incoming message_id: {}",
+                format_exception_for_log(
+                    e, log_full_message=self._log_messaging_error_details
+                ),
+            )
+
+        if await dispatch_command(self._command_context, incoming, cmd_base):
+            return
+
+        text = incoming.text or ""
+        if any(text.startswith(p) for p in STATUS_MESSAGE_PREFIXES):
+            return
+
+        parent_node_id = None
+        tree = None
+        tree_queue = self._get_tree_queue()
+
+        if incoming.is_reply() and incoming.reply_to_message_id:
+            reply_id = incoming.reply_to_message_id
+            tree = tree_queue.get_tree_for_node(reply_id)
+            if tree:
+                parent_node_id = tree_queue.resolve_parent_node_id(reply_id)
+                if parent_node_id:
+                    logger.info(f"Found tree for reply, parent node: {parent_node_id}")
+                else:
+                    logger.warning(
+                        f"Reply to {incoming.reply_to_message_id} found tree but no valid parent node"
+                    )
+                    tree = None
+
+        node_id = incoming.message_id
+        status_text = self._get_initial_status(tree, parent_node_id)
+        if incoming.status_message_id:
+            status_msg_id = incoming.status_message_id
+            await self.platform.queue_edit_message(
+                incoming.chat_id,
+                status_msg_id,
+                status_text,
+                parse_mode=self._get_parse_mode(),
+                fire_and_forget=False,
+            )
+        else:
+            status_msg_id = await self.platform.queue_send_message(
+                incoming.chat_id,
+                status_text,
+                reply_to=incoming.message_id,
+                fire_and_forget=False,
+                message_thread_id=incoming.message_thread_id,
+            )
+        self._record_outgoing_message(
+            incoming.platform, incoming.chat_id, status_msg_id, "status"
+        )
+
+        tree_queue = self._get_tree_queue()
+        if parent_node_id and tree and status_msg_id:
+            tree, _node = await tree_queue.add_to_tree(
+                parent_node_id=parent_node_id,
+                node_id=node_id,
+                incoming=incoming,
+                status_message_id=status_msg_id,
+            )
+            tree_queue.register_node(status_msg_id, tree.root_id)
+            self.session_store.register_node(status_msg_id, tree.root_id)
+            self.session_store.register_node(node_id, tree.root_id)
+        elif status_msg_id:
+            tree = await tree_queue.create_tree(
+                node_id=node_id,
+                incoming=incoming,
+                status_message_id=status_msg_id,
+            )
+            tree_queue.register_node(status_msg_id, tree.root_id)
+            self.session_store.register_node(node_id, tree.root_id)
+            self.session_store.register_node(status_msg_id, tree.root_id)
+
+        if tree:
+            self.session_store.save_tree(tree.root_id, tree.to_dict())
+
+        was_queued = await tree_queue.enqueue(
+            node_id=node_id,
+            processor=self._process_node,
+        )
+
+        if was_queued and status_msg_id:
+            queue_size = tree_queue.get_queue_size(node_id)
+            trace_event(
+                stage="routing",
+                event="turn.queued",
+                source=getattr(self.platform, "name", "messaging"),
+                chat_id=incoming.chat_id,
+                platform_message_id=node_id,
+                status_message_id=status_msg_id,
+                queue_size=queue_size,
+            )
+            await self.platform.queue_edit_message(
+                incoming.chat_id,
+                status_msg_id,
+                self._format_status(
+                    "📋", "Queued", f"(position {queue_size}) - waiting..."
+                ),
+                parse_mode=self._get_parse_mode(),
+            )
+
+    async def update_queue_positions(self, tree: MessageTree) -> None:
+        """Refresh queued status messages after a dequeue."""
+        try:
+            queued_ids = await tree.get_queue_snapshot()
+        except Exception as e:
+            logger.warning(
+                "Failed to read queue snapshot: {}",
+                format_exception_for_log(
+                    e, log_full_message=self._log_messaging_error_details
+                ),
+            )
+            return
+
+        if not queued_ids:
+            return
+
+        position = 0
+        for node_id in queued_ids:
+            node = tree.get_node(node_id)
+            if not node or node.state != MessageState.PENDING:
+                continue
+            position += 1
+            self.platform.fire_and_forget(
+                self.platform.queue_edit_message(
+                    node.incoming.chat_id,
+                    node.status_message_id,
+                    self._format_status(
+                        "📋", "Queued", f"(position {position}) - waiting..."
+                    ),
+                    parse_mode=self._get_parse_mode(),
+                )
+            )
+
+    async def mark_node_processing(self, tree: MessageTree, node_id: str) -> None:
+        """Update the dequeued node's status to processing immediately."""
+        node = tree.get_node(node_id)
+        if not node or node.state == MessageState.ERROR:
+            return
+        self.platform.fire_and_forget(
+            self.platform.queue_edit_message(
+                node.incoming.chat_id,
+                node.status_message_id,
+                self._format_status("🔄", "Processing...", None),
+                parse_mode=self._get_parse_mode(),
+            )
+        )
+
+    def _get_initial_status(
+        self,
+        tree: object | None,
+        parent_node_id: str | None,
+    ) -> str:
+        """Get initial status message text."""
+        tree_queue = self._get_tree_queue()
+        if tree and parent_node_id:
+            if tree_queue.is_node_tree_busy(parent_node_id):
+                queue_size = tree_queue.get_queue_size(parent_node_id) + 1
+                return self._format_status(
+                    "📋", "Queued", f"(position {queue_size}) - waiting..."
+                )
+            return self._format_status("🔄", "Continuing conversation...", None)
+
+        return self._format_status("⏳", "Launching new Claude CLI instance...", None)
+
+
+__all__ = ["MessagingTurnIntake"]

messaging/ui_updates.py

@@ -0,0 +1,101 @@
+"""Throttled platform UI updates driven by transcript rendering."""
+
+from __future__ import annotations
+
+import time
+from collections.abc import Callable
+
+from loguru import logger
+
+from .platforms.base import MessagingPlatform
+from .safe_diagnostics import format_exception_for_log
+from .transcript import RenderCtx, TranscriptBuffer
+
+
+class ThrottledTranscriptEditor:
+    """Rate-limited status message edits from a growing transcript."""
+
+    def __init__(
+        self,
+        *,
+        platform: MessagingPlatform,
+        parse_mode: str | None,
+        get_limit_chars: Callable[[], int],
+        transcript: TranscriptBuffer,
+        render_ctx: RenderCtx,
+        node_id: str,
+        chat_id: str,
+        status_msg_id: str,
+        debug_platform_edits: bool,
+        log_messaging_error_details: bool = False,
+    ) -> None:
+        self._platform = platform
+        self._parse_mode = parse_mode
+        self._get_limit_chars = get_limit_chars
+        self._transcript = transcript
+        self._render_ctx = render_ctx
+        self._node_id = node_id
+        self._chat_id = chat_id
+        self._status_msg_id = status_msg_id
+        self._debug_platform_edits = debug_platform_edits
+        self._log_messaging_error_details = log_messaging_error_details
+        self._last_ui_update = 0.0
+        self._last_displayed_text: str | None = None
+        self._last_status: str | None = None
+
+    @property
+    def last_status(self) -> str | None:
+        return self._last_status
+
+    async def update(self, status: str | None = None, *, force: bool = False) -> None:
+        """Render transcript + optional status line and edit the platform message."""
+        now = time.time()
+        if not force and now - self._last_ui_update < 1.0:
+            return
+
+        self._last_ui_update = now
+        if status is not None:
+            self._last_status = status
+        try:
+            display = self._transcript.render(
+                self._render_ctx,
+                limit_chars=self._get_limit_chars(),
+                status=status,
+            )
+        except Exception as e:
+            logger.warning(
+                "Transcript render failed for node {}: {}",
+                self._node_id,
+                format_exception_for_log(
+                    e, log_full_message=self._log_messaging_error_details
+                ),
+            )
+            return
+        if display and display != self._last_displayed_text:
+            logger.debug(
+                "PLATFORM_EDIT: node_id={} chat_id={} msg_id={} force={} status={!r} chars={}",
+                self._node_id,
+                self._chat_id,
+                self._status_msg_id,
+                bool(force),
+                status,
+                len(display),
+            )
+            if self._debug_platform_edits:
+                logger.debug("PLATFORM_EDIT_TEXT:\n{}", display)
+            self._last_displayed_text = display
+            try:
+                await self._platform.queue_edit_message(
+                    self._chat_id,
+                    self._status_msg_id,
+                    display,
+                    parse_mode=self._parse_mode,
+                )
+            except Exception as e:
+                logger.warning(
+                    "Failed to update platform for node {}: {}",
+                    self._node_id,
+                    format_exception_for_log(
+                        e, log_full_message=self._log_messaging_error_details
+                    ),
+                )

messaging/voice.py

@@ -0,0 +1,76 @@
+"""Platform-neutral voice note helpers."""
+
+from __future__ import annotations
+
+import asyncio
+from pathlib import Path
+
+
+class PendingVoiceRegistry:
+    """Track voice notes that are still waiting on transcription."""
+
+    def __init__(self) -> None:
+        self._pending: dict[tuple[str, str], tuple[str, str]] = {}
+        self._lock = asyncio.Lock()
+
+    async def register(
+        self, chat_id: str, voice_msg_id: str, status_msg_id: str
+    ) -> None:
+        async with self._lock:
+            entry = (voice_msg_id, status_msg_id)
+            self._pending[(chat_id, voice_msg_id)] = entry
+            self._pending[(chat_id, status_msg_id)] = entry
+
+    async def cancel(self, chat_id: str, reply_id: str) -> tuple[str, str] | None:
+        async with self._lock:
+            entry = self._pending.pop((chat_id, reply_id), None)
+            if entry is None:
+                return None
+            voice_msg_id, status_msg_id = entry
+            self._pending.pop((chat_id, voice_msg_id), None)
+            self._pending.pop((chat_id, status_msg_id), None)
+            return entry
+
+    async def is_pending(self, chat_id: str, voice_msg_id: str) -> bool:
+        async with self._lock:
+            return (chat_id, voice_msg_id) in self._pending
+
+    async def complete(
+        self, chat_id: str, voice_msg_id: str, status_msg_id: str
+    ) -> None:
+        async with self._lock:
+            self._pending.pop((chat_id, voice_msg_id), None)
+            self._pending.pop((chat_id, status_msg_id), None)
+
+
+class VoiceTranscriptionService:
+    """Run configured transcription backends off the event loop."""
+
+    def __init__(
+        self,
+        *,
+        hf_token: str = "",
+        nvidia_nim_api_key: str = "",
+    ) -> None:
+        self._hf_token = hf_token
+        self._nvidia_nim_api_key = nvidia_nim_api_key
+
+    async def transcribe(
+        self,
+        file_path: Path,
+        mime_type: str,
+        *,
+        whisper_model: str,
+        whisper_device: str,
+    ) -> str:
+        from .transcription import transcribe_audio
+
+        return await asyncio.to_thread(
+            transcribe_audio,
+            file_path,
+            mime_type,
+            whisper_model=whisper_model,
+            whisper_device=whisper_device,
+            hf_token=self._hf_token,
+            nvidia_nim_api_key=self._nvidia_nim_api_key,
+        )