devcopilot 0.2.0__py3-none-any.whl

messaging/commands.py

@@ -0,0 +1,275 @@
+"""Command handlers for messaging platform commands (/stop, /stats, /clear).
+
+Commands depend on MessagingCommandContext instead of the concrete workflow.
+"""
+
+from __future__ import annotations
+
+from typing import TYPE_CHECKING
+
+from loguru import logger
+
+from .command_context import MessagingCommandContext
+
+if TYPE_CHECKING:
+    from messaging.models import IncomingMessage
+
+
+async def handle_stop_command(
+    handler: MessagingCommandContext, incoming: IncomingMessage
+) -> None:
+    """Handle /stop command from messaging platform."""
+    # Reply-scoped stop: reply "/stop" to stop only that task.
+    if incoming.is_reply() and incoming.reply_to_message_id:
+        reply_id = incoming.reply_to_message_id
+        tree = handler.tree_queue.get_tree_for_node(reply_id)
+        node_id = handler.tree_queue.resolve_parent_node_id(reply_id) if tree else None
+
+        if not node_id:
+            msg_id = await handler.platform.queue_send_message(
+                incoming.chat_id,
+                handler.format_status(
+                    "⏹", "Stopped.", "Nothing to stop for that message."
+                ),
+                fire_and_forget=False,
+                message_thread_id=incoming.message_thread_id,
+            )
+            handler.record_outgoing_message(
+                incoming.platform, incoming.chat_id, msg_id, "command"
+            )
+            return
+
+        count = await handler.stop_task(node_id)
+        noun = "request" if count == 1 else "requests"
+        msg_id = await handler.platform.queue_send_message(
+            incoming.chat_id,
+            handler.format_status("⏹", "Stopped.", f"Cancelled {count} {noun}."),
+            fire_and_forget=False,
+            message_thread_id=incoming.message_thread_id,
+        )
+        handler.record_outgoing_message(
+            incoming.platform, incoming.chat_id, msg_id, "command"
+        )
+        return
+
+    # Global stop: legacy behavior (stop everything)
+    count = await handler.stop_all_tasks()
+    msg_id = await handler.platform.queue_send_message(
+        incoming.chat_id,
+        handler.format_status(
+            "⏹", "Stopped.", f"Cancelled {count} pending or active requests."
+        ),
+        fire_and_forget=False,
+        message_thread_id=incoming.message_thread_id,
+    )
+    handler.record_outgoing_message(
+        incoming.platform, incoming.chat_id, msg_id, "command"
+    )
+
+
+async def handle_stats_command(
+    handler: MessagingCommandContext, incoming: IncomingMessage
+) -> None:
+    """Handle /stats command."""
+    stats = handler.cli_manager.get_stats()
+    tree_count = handler.tree_queue.get_tree_count()
+    ctx = handler.get_render_ctx()
+    msg_id = await handler.platform.queue_send_message(
+        incoming.chat_id,
+        "📊 "
+        + ctx.bold("Stats")
+        + "\n"
+        + ctx.escape_text(f"• Active CLI: {stats['active_sessions']}")
+        + "\n"
+        + ctx.escape_text(f"• Message Trees: {tree_count}"),
+        fire_and_forget=False,
+        message_thread_id=incoming.message_thread_id,
+    )
+    handler.record_outgoing_message(
+        incoming.platform, incoming.chat_id, msg_id, "command"
+    )
+
+
+async def _delete_message_ids(
+    handler: MessagingCommandContext, chat_id: str, msg_ids: set[str]
+) -> None:
+    """Best-effort delete messages by ID. Sorts numeric IDs descending."""
+    if not msg_ids:
+        return
+
+    def _as_int(s: str) -> int | None:
+        try:
+            return int(str(s))
+        except Exception:
+            return None
+
+    numeric: list[tuple[int, str]] = []
+    non_numeric: list[str] = []
+    for mid in msg_ids:
+        n = _as_int(mid)
+        if n is None:
+            non_numeric.append(mid)
+        else:
+            numeric.append((n, mid))
+    numeric.sort(reverse=True)
+    ordered = [mid for _, mid in numeric] + non_numeric
+
+    try:
+        CHUNK = 100
+        for i in range(0, len(ordered), CHUNK):
+            chunk = ordered[i : i + CHUNK]
+            await handler.platform.queue_delete_messages(
+                chat_id, chunk, fire_and_forget=False
+            )
+    except Exception as e:
+        logger.debug(f"Batch delete failed: {type(e).__name__}: {e}")
+
+
+async def _handle_clear_branch(
+    handler: MessagingCommandContext,
+    incoming: IncomingMessage,
+    branch_root_id: str,
+) -> None:
+    """
+    Clear a branch (replied-to node + all descendants).
+
+    Order: cancel tasks, delete messages, remove branch, update session store.
+    """
+    tree = handler.tree_queue.get_tree_for_node(branch_root_id)
+    if not tree:
+        return
+
+    # 1) Cancel branch tasks (no stop_all)
+    cancelled = await handler.tree_queue.cancel_branch(branch_root_id)
+    handler.update_cancelled_nodes_ui(cancelled)
+
+    # 2) Collect message IDs from branch nodes only
+    msg_ids: set[str] = set()
+    branch_ids = tree.get_descendants(branch_root_id)
+    for nid in branch_ids:
+        node = tree.get_node(nid)
+        if node:
+            if node.incoming.message_id:
+                msg_ids.add(str(node.incoming.message_id))
+            if node.status_message_id:
+                msg_ids.add(str(node.status_message_id))
+    if incoming.message_id:
+        msg_ids.add(str(incoming.message_id))
+
+    # 3) Delete messages (best-effort)
+    await _delete_message_ids(handler, incoming.chat_id, msg_ids)
+
+    # 4) Remove branch from tree
+    removed, root_id, removed_entire_tree = await handler.tree_queue.remove_branch(
+        branch_root_id
+    )
+
+    # 5) Update session store
+    try:
+        handler.session_store.remove_node_mappings([n.node_id for n in removed])
+        if removed_entire_tree:
+            handler.session_store.remove_tree(root_id)
+        else:
+            updated_tree = handler.tree_queue.get_tree(root_id)
+            if updated_tree:
+                handler.session_store.save_tree(root_id, updated_tree.to_dict())
+    except Exception as e:
+        logger.warning(f"Failed to update session store after branch clear: {e}")
+
+
+async def handle_clear_command(
+    handler: MessagingCommandContext, incoming: IncomingMessage
+) -> None:
+    """
+    Handle /clear command.
+
+    Reply-scoped: reply to a message to clear that branch (node + descendants).
+    Standalone: global clear (stop all, delete all chat messages, reset store).
+    """
+    from messaging.trees import TreeQueueManager
+
+    if incoming.is_reply() and incoming.reply_to_message_id:
+        reply_id = incoming.reply_to_message_id
+        tree = handler.tree_queue.get_tree_for_node(reply_id)
+        branch_root_id = (
+            handler.tree_queue.resolve_parent_node_id(reply_id) if tree else None
+        )
+        if not branch_root_id:
+            cancel_fn = getattr(handler.platform, "cancel_pending_voice", None)
+            if cancel_fn is not None:
+                cancelled = await cancel_fn(incoming.chat_id, reply_id)
+                if cancelled is not None:
+                    voice_msg_id, status_msg_id = cancelled
+                    msg_ids_to_del: set[str] = {voice_msg_id, status_msg_id}
+                    if incoming.message_id is not None:
+                        msg_ids_to_del.add(str(incoming.message_id))
+                    await _delete_message_ids(handler, incoming.chat_id, msg_ids_to_del)
+                    msg_id = await handler.platform.queue_send_message(
+                        incoming.chat_id,
+                        handler.format_status("🗑", "Cleared.", "Voice note cancelled."),
+                        fire_and_forget=False,
+                        message_thread_id=incoming.message_thread_id,
+                    )
+                    handler.record_outgoing_message(
+                        incoming.platform, incoming.chat_id, msg_id, "command"
+                    )
+                    return
+            msg_id = await handler.platform.queue_send_message(
+                incoming.chat_id,
+                handler.format_status(
+                    "🗑", "Cleared.", "Nothing to clear for that message."
+                ),
+                fire_and_forget=False,
+                message_thread_id=incoming.message_thread_id,
+            )
+            handler.record_outgoing_message(
+                incoming.platform, incoming.chat_id, msg_id, "command"
+            )
+            return
+        await _handle_clear_branch(handler, incoming, branch_root_id)
+        return
+
+    # Global clear
+    # 1) Stop tasks first (ensures no more work is running).
+    await handler.stop_all_tasks()
+
+    # 2) Clear chat: best-effort delete messages we can identify.
+    msg_ids: set[str] = set()
+
+    # Add any recorded message IDs for this chat (commands, command replies, etc).
+    try:
+        for mid in handler.session_store.get_message_ids_for_chat(
+            incoming.platform, incoming.chat_id
+        ):
+            if mid is not None:
+                msg_ids.add(str(mid))
+    except Exception as e:
+        logger.debug(f"Failed to read message log for /clear: {e}")
+
+    try:
+        msg_ids.update(
+            handler.tree_queue.get_message_ids_for_chat(
+                incoming.platform, incoming.chat_id
+            )
+        )
+    except Exception as e:
+        logger.warning(f"Failed to gather messages for /clear: {e}")
+
+    # Also delete the command message itself.
+    if incoming.message_id is not None:
+        msg_ids.add(str(incoming.message_id))
+
+    await _delete_message_ids(handler, incoming.chat_id, msg_ids)
+
+    # 3) Clear persistent state and reset in-memory queue/tree state.
+    try:
+        handler.session_store.clear_all()
+    except Exception as e:
+        logger.warning(f"Failed to clear session store: {e}")
+
+    handler.replace_tree_queue(
+        TreeQueueManager(
+            queue_update_callback=handler.update_queue_positions,
+            node_started_callback=handler.mark_node_processing,
+        )
+    )

messaging/event_parser.py

@@ -0,0 +1,181 @@
+"""CLI event parser for Claude Code CLI output.
+
+This parser emits an ordered stream of low-level events suitable for building a
+Claude Code-like transcript in messaging UIs.
+"""
+
+from typing import Any
+
+from loguru import logger
+
+
+def parse_cli_event(event: Any, *, log_raw_cli: bool = False) -> list[dict]:
+    """
+    Parse a CLI event and return a structured result.
+
+    Args:
+        event: Raw event dictionary from CLI
+        log_raw_cli: When True, log full error text from the CLI. Default is
+            metadata-only (lengths / exit codes) to avoid leaking user content.
+
+    Returns:
+        List of parsed event dicts. Empty list if not recognized.
+    """
+    if not isinstance(event, dict):
+        return []
+
+    etype = event.get("type")
+    results: list[dict[str, Any]] = []
+
+    # Some CLI/proxy layers emit "system" events that are not user-visible and
+    # carry no transcript content. Ignore them explicitly to avoid noisy logs.
+    if etype == "system":
+        return []
+
+    # 1. Handle full messages (assistant/user or result)
+    msg_obj = None
+    if etype == "assistant" or etype == "user":
+        msg_obj = event.get("message")
+    elif etype == "result":
+        res = event.get("result")
+        if isinstance(res, dict):
+            msg_obj = res.get("message")
+            # Some variants put content directly on the result.
+            if not msg_obj and isinstance(res.get("content"), list):
+                msg_obj = {"content": res.get("content")}
+        if not msg_obj:
+            msg_obj = event.get("message")
+        # Some variants put content directly on the event.
+        if not msg_obj and isinstance(event.get("content"), list):
+            msg_obj = {"content": event.get("content")}
+
+    if msg_obj and isinstance(msg_obj, dict):
+        content = msg_obj.get("content", [])
+        if isinstance(content, list):
+            # Preserve order exactly as content blocks appear.
+            for c in content:
+                if not isinstance(c, dict):
+                    continue
+                ctype = c.get("type")
+                if ctype == "text":
+                    results.append({"type": "text_chunk", "text": c.get("text", "")})
+                elif ctype == "thinking":
+                    results.append(
+                        {"type": "thinking_chunk", "text": c.get("thinking", "")}
+                    )
+                elif ctype == "tool_use":
+                    results.append(
+                        {
+                            "type": "tool_use",
+                            "id": str(c.get("id", "") or "").strip(),
+                            "name": c.get("name", ""),
+                            "input": c.get("input"),
+                        }
+                    )
+                elif ctype == "tool_result":
+                    results.append(
+                        {
+                            "type": "tool_result",
+                            "tool_use_id": str(c.get("tool_use_id", "") or "").strip(),
+                            "content": c.get("content"),
+                            "is_error": bool(c.get("is_error", False)),
+                        }
+                    )
+
+        if results:
+            return results
+
+    # 2. Handle streaming deltas
+    if etype == "content_block_delta":
+        delta = event.get("delta", {})
+        if isinstance(delta, dict):
+            if delta.get("type") == "text_delta":
+                return [
+                    {
+                        "type": "text_delta",
+                        "index": event.get("index", -1),
+                        "text": delta.get("text", ""),
+                    }
+                ]
+            if delta.get("type") == "thinking_delta":
+                return [
+                    {
+                        "type": "thinking_delta",
+                        "index": event.get("index", -1),
+                        "text": delta.get("thinking", ""),
+                    }
+                ]
+            if delta.get("type") == "input_json_delta":
+                return [
+                    {
+                        "type": "tool_use_delta",
+                        "index": event.get("index", -1),
+                        "partial_json": delta.get("partial_json", ""),
+                    }
+                ]
+
+    # 3. Handle tool usage start
+    if etype == "content_block_start":
+        block = event.get("content_block", {})
+        if isinstance(block, dict):
+            btype = block.get("type")
+            if btype == "thinking":
+                return [{"type": "thinking_start", "index": event.get("index", -1)}]
+            if btype == "text":
+                return [{"type": "text_start", "index": event.get("index", -1)}]
+            if btype == "tool_use":
+                return [
+                    {
+                        "type": "tool_use_start",
+                        "index": event.get("index", -1),
+                        "id": str(block.get("id", "") or "").strip(),
+                        "name": block.get("name", ""),
+                        "input": block.get("input"),
+                    }
+                ]
+
+    # 3.5 Handle block stop (to close open streaming segments)
+    if etype == "content_block_stop":
+        return [{"type": "block_stop", "index": event.get("index", -1)}]
+
+    # 4. Handle errors and exit
+    if etype == "error":
+        err = event.get("error")
+        msg = err.get("message") if isinstance(err, dict) else str(err)
+        if log_raw_cli:
+            logger.info("CLI_PARSER: Parsed error event: {}", msg)
+        else:
+            mlen = len(msg) if isinstance(msg, str) else 0
+            logger.info("CLI_PARSER: Parsed error event: message_chars={}", mlen)
+        return [{"type": "error", "message": msg}]
+    elif etype == "exit":
+        code = event.get("code", 0)
+        stderr = event.get("stderr")
+        if code == 0:
+            logger.debug(f"CLI_PARSER: Successful exit (code={code})")
+            return [{"type": "complete", "status": "success"}]
+        else:
+            # Non-zero exit is an error
+            error_msg = stderr if stderr else f"Process exited with code {code}"
+            if log_raw_cli:
+                logger.warning(
+                    "CLI_PARSER: Error exit (code={}): {}",
+                    code,
+                    error_msg,
+                )
+            else:
+                em = error_msg if isinstance(error_msg, str) else str(error_msg)
+                logger.warning(
+                    "CLI_PARSER: Error exit (code={}): message_chars={}",
+                    code,
+                    len(em),
+                )
+            return [
+                {"type": "error", "message": error_msg},
+                {"type": "complete", "status": "failed"},
+            ]
+
+    # Log unrecognized events for debugging
+    if etype:
+        logger.debug(f"CLI_PARSER: Unrecognized event type: {etype}")
+    return []