chorus-cli 0.4.0

package/tools/qa.py

@@ -0,0 +1,528 @@
+#!/usr/bin/env python3
+"""
+QA Chat — Multi-turn QA conversation tool powered by Claude + pluggable messengers.
+
+Supports Teams (Playwright browser automation) and Slack (API-based).
+
+Usage:
+    echo '{"issue_number":4464,...}' | qa.py --messenger teams --auth teams-auth.json --qa "zuki dlomo"
+    echo '{"issue_number":4464,...}' | qa.py --messenger slack --qa "zuki dlomo"
+
+Input (JSON on stdin):
+    issue_number, issue_title, issue_body, enriched_questions
+
+Output (JSON on stdout):
+    completed, requirements, conversation_rounds, raw_responses
+
+Progress is logged to stderr.
+"""
+
+import anthropic
+import argparse
+import json
+import os
+import sys
+import time
+from abc import ABC, abstractmethod
+
+# ── Config ──────────────────────────────────────────────────────────────────
+
+MODEL = os.environ.get("QA_MODEL", "claude-sonnet-4-5-20250929")
+MAX_ROUNDS = int(os.environ.get("QA_MAX_ROUNDS", "5"))
+POLL_INTERVAL = int(os.environ.get("QA_POLL_INTERVAL", "60"))  # seconds
+POLL_TIMEOUT = int(os.environ.get("QA_POLL_TIMEOUT", "1800"))  # 30 min
+
+def is_token_limit_error(err):
+    msg = str(err)
+    return "token limit exceeded" in msg or "rate_limit_error" in msg
+
+# ── Logging (stderr only) ──────────────────────────────────────────────────
+
+def log(msg):
+    print(msg, file=sys.stderr, flush=True)
+
+# ── Messenger Interface ────────────────────────────────────────────────────
+
+class Messenger(ABC):
+    @abstractmethod
+    def connect(self):
+        ...
+
+    @abstractmethod
+    def navigate_to_chat(self, name: str):
+        ...
+
+    @abstractmethod
+    def send_message(self, text: str):
+        ...
+
+    @abstractmethod
+    def wait_for_response(self) -> str:
+        ...
+
+    @abstractmethod
+    def close(self):
+        ...
+
+# ── Teams Messenger (Playwright) ──────────────────────────────────────────
+
+class TeamsMessenger(Messenger):
+    def __init__(self, auth_path):
+        self.auth_path = auth_path
+        self.browser = None
+        self.page = None
+
+    def connect(self):
+        from playwright.sync_api import sync_playwright
+        self._pw = sync_playwright().start()
+        self.browser = self._pw.firefox.launch(headless=False)
+        context = self.browser.new_context(storage_state=self.auth_path)
+        self.page = context.new_page()
+        self.page.set_default_timeout(60000)
+        log("  Loading Teams...")
+        self.page.goto("https://teams.microsoft.com", wait_until="domcontentloaded", timeout=120000)
+        self.page.wait_for_timeout(60000)
+        log("  Teams loaded")
+
+    def navigate_to_chat(self, name):
+        page = self.page
+        log(f"  Navigating to Chat section...")
+        chat_btn = page.locator('[data-tid="app-bar-Chat"]')
+        if chat_btn.count() == 0:
+            chat_btn = page.locator('button:has-text("Chat"), [aria-label="Chat"]').first
+        chat_btn.click()
+        page.wait_for_timeout(30000)
+
+        log(f"  Searching for {name}...")
+        search = page.locator('#ms-searchux-input')
+        search.click()
+        page.wait_for_timeout(500)
+        search.fill(name)
+        page.wait_for_timeout(3000)
+
+        page.keyboard.press("ArrowDown")
+        page.wait_for_timeout(500)
+        page.keyboard.press("ArrowDown")
+        page.wait_for_timeout(500)
+        page.keyboard.press("Enter")
+
+        page.wait_for_timeout(5000)
+        log(f"  Opened chat with {name}")
+
+    def send_message(self, text):
+        page = self.page
+        try:
+            compose = page.locator('[data-tid="ckeditor"]').first
+            compose.fill(text)
+            page.keyboard.press("Enter")
+        except Exception:
+            compose = page.locator('[role="textbox"]').first
+            compose.fill(text)
+            page.keyboard.press("Enter")
+        page.wait_for_timeout(1000)
+
+    def _snapshot(self):
+        page = self.page
+        msgs = page.locator('[data-tid="chat-pane-message"]')
+        count = msgs.count()
+        if count > 0:
+            last = msgs.last
+            mid = last.get_attribute("data-mid") or ""
+            content = last.locator("[data-message-content]")
+            text = (content.text_content() or "").strip() if content.count() > 0 else ""
+            return count, mid, text
+        return 0, "", ""
+
+    def wait_for_response(self):
+        before_count, before_mid, before_text = self._snapshot()
+        log(f"  Tracking messages (count={before_count}, last_mid={before_mid})")
+
+        elapsed = 0
+        while elapsed < POLL_TIMEOUT:
+            self.page.wait_for_timeout(POLL_INTERVAL * 1000)
+            elapsed += POLL_INTERVAL
+
+            now_count, now_mid, now_text = self._snapshot()
+
+            if now_mid and now_mid != before_mid:
+                log(f"  New message detected (mid={now_mid})")
+                return now_text
+
+            log(f"  Waiting for QA response... ({elapsed}s, msgs={now_count})")
+
+        raise TimeoutError(f"No QA response after {POLL_TIMEOUT}s")
+
+    def close(self):
+        if self.browser:
+            self.browser.close()
+        if hasattr(self, '_pw'):
+            self._pw.stop()
+
+# ── Slack Messenger (API) ─────────────────────────────────────────────────
+
+class SlackMessenger(Messenger):
+    def __init__(self, bot_token):
+        self.bot_token = bot_token
+        self.client = None
+        self.channel_id = None
+        self.bot_user_id = None
+        self.last_ts = None
+
+    def connect(self):
+        from slack_sdk import WebClient
+        from slack_sdk.errors import SlackApiError
+
+        self.client = WebClient(token=self.bot_token)
+        auth = self.client.auth_test()
+        self.bot_user_id = auth["user_id"]
+        log(f"  Slack connected as {auth['user']} (team: {auth['team']})")
+
+    def navigate_to_chat(self, name):
+        log(f"  Finding Slack user '{name}'...")
+        cursor = None
+        target_user_id = None
+
+        while True:
+            kwargs = {"limit": 200}
+            if cursor:
+                kwargs["cursor"] = cursor
+            resp = self.client.users_list(**kwargs)
+
+            for member in resp["members"]:
+                if member.get("deleted") or member.get("is_bot"):
+                    continue
+                profile = member.get("profile", {})
+                display = profile.get("display_name", "") or ""
+                real = profile.get("real_name", "") or ""
+                if name.lower() in display.lower() or name.lower() in real.lower():
+                    target_user_id = member["id"]
+                    log(f"  Matched user: {real} ({display}) — {target_user_id}")
+                    break
+
+            if target_user_id:
+                break
+
+            cursor = resp.get("response_metadata", {}).get("next_cursor")
+            if not cursor:
+                break
+
+        if not target_user_id:
+            raise RuntimeError(f"Could not find Slack user matching '{name}'")
+
+        dm = self.client.conversations_open(users=[target_user_id])
+        self.channel_id = dm["channel"]["id"]
+        log(f"  Opened DM channel {self.channel_id}")
+
+    def send_message(self, text):
+        resp = self.client.chat_postMessage(channel=self.channel_id, text=text)
+        self.last_ts = resp["ts"]
+        log(f"  Message sent (ts={self.last_ts})")
+
+    def wait_for_response(self):
+        log(f"  Polling for Slack response (interval={POLL_INTERVAL}s, timeout={POLL_TIMEOUT}s)...")
+        elapsed = 0
+        while elapsed < POLL_TIMEOUT:
+            time.sleep(POLL_INTERVAL)
+            elapsed += POLL_INTERVAL
+
+            resp = self.client.conversations_history(
+                channel=self.channel_id,
+                oldest=self.last_ts,
+                limit=10,
+            )
+
+            for msg in resp.get("messages", []):
+                # Skip our own bot messages
+                if msg.get("user") == self.bot_user_id:
+                    continue
+                if msg.get("bot_id"):
+                    continue
+                # Found a human reply
+                text = msg.get("text", "").strip()
+                if text:
+                    self.last_ts = msg["ts"]
+                    log(f"  Slack response received ({len(text)} chars)")
+                    return text
+
+            log(f"  Waiting for QA response... ({elapsed}s)")
+
+        raise TimeoutError(f"No QA response after {POLL_TIMEOUT}s")
+
+    def close(self):
+        pass  # No persistent connection to tear down
+
+# ── Shared Helpers ─────────────────────────────────────────────────────────
+
+def split_questions(text):
+    """Split enriched questions into intro + individual numbered questions."""
+    import re
+    parts = re.split(r'\n(?=\d+\.\s)', text)
+    result = []
+    for part in parts:
+        stripped = part.strip()
+        if stripped:
+            result.append(stripped)
+    return result if len(result) > 1 else [text.strip()]
+
+
+EVALUATE_TOOLS = [
+    {
+        "name": "evaluation",
+        "description": "Return your evaluation of the QA conversation.",
+        "input_schema": {
+            "type": "object",
+            "properties": {
+                "sufficient": {
+                    "type": "boolean",
+                    "description": "True if there is enough info to write exact developer requirements.",
+                },
+                "reasoning": {
+                    "type": "string",
+                    "description": "Brief explanation of why info is or isn't sufficient.",
+                },
+                "follow_up": {
+                    "type": "string",
+                    "description": "Follow-up message to send to QA. Required if sufficient is false. MUST be plain text — no markdown, no **bold**, no bullets. Use numbered lines (1. 2. 3.) for multiple questions.",
+                },
+            },
+            "required": ["sufficient", "reasoning"],
+        },
+    }
+]
+
+
+def evaluate_response(client, conversation, issue_context):
+    convo_text = "\n\n".join(
+        f"{'QA' if m['from'] == 'qa' else 'Bot'}: {m['text']}" for m in conversation
+    )
+
+    messages = [
+        {
+            "role": "user",
+            "content": f"""Evaluate this QA conversation about a GitHub issue.
+
+ISSUE:
+  Number: {issue_context['issue_number']}
+  Title: {issue_context['issue_title']}
+  Body: {issue_context.get('issue_body', 'N/A')}
+
+CONVERSATION SO FAR:
+{convo_text}
+
+Decide: do you have enough specific information to write exact, actionable developer requirements?
+
+If YES: set sufficient=true and explain why.
+If NO: set sufficient=false and write a short, friendly follow-up message asking QA for the missing details. Be specific about what you still need — don't repeat questions already answered.""",
+        }
+    ]
+
+    response = client.messages.create(
+        model=MODEL,
+        max_tokens=1024,
+        system=(
+            "You are evaluating a QA conversation about a software bug/feature. "
+            "Your job is to decide if there is enough concrete information to write "
+            "exact developer requirements. Vague answers like 'it should work properly' "
+            "are NOT sufficient — you need specifics: exact behavior, exact UI elements, "
+            "exact data flows, exact error messages, etc. "
+            "Use the evaluation tool to return your assessment. "
+            "IMPORTANT: follow_up messages are sent via chat. Use plain text only — "
+            "no markdown, no **bold**, no *italic*, no bullet points. "
+            "Use numbered lines (1. 2. 3.) for multiple questions. Keep it conversational."
+        ),
+        tools=EVALUATE_TOOLS,
+        tool_choice={"type": "tool", "name": "evaluation"},
+        messages=messages,
+    )
+
+    if hasattr(response, "usage") and response.usage:
+        log(f"  Evaluate tokens: {response.usage.input_tokens} in / {response.usage.output_tokens} out")
+
+    for block in response.content:
+        if block.type == "tool_use" and block.name == "evaluation":
+            return block.input
+
+    raise RuntimeError("Claude did not return evaluation tool call")
+
+
+def synthesize(client, conversation, issue_context):
+    convo_text = "\n\n".join(
+        f"{'QA' if m['from'] == 'qa' else 'Bot'}: {m['text']}" for m in conversation
+    )
+
+    messages = [
+        {
+            "role": "user",
+            "content": f"""Synthesize this QA conversation into exact, actionable developer requirements.
+
+ISSUE:
+  Number: {issue_context['issue_number']}
+  Title: {issue_context['issue_title']}
+  Body: {issue_context.get('issue_body', 'N/A')}
+
+FULL QA CONVERSATION:
+{convo_text}
+
+Write a clear numbered list of requirements. Each requirement should be specific enough that a developer can implement it without asking further questions. Include exact UI elements, exact behavior, exact data flows, edge cases, and acceptance criteria where discussed.""",
+        }
+    ]
+
+    response = client.messages.create(
+        model=MODEL,
+        max_tokens=2048,
+        system=(
+            "You synthesize QA conversations into exact, actionable developer requirements. "
+            "Be specific and concrete. No vague language. Every requirement should be testable."
+        ),
+        messages=messages,
+    )
+
+    if hasattr(response, "usage") and response.usage:
+        log(f"  Synthesize tokens: {response.usage.input_tokens} in / {response.usage.output_tokens} out")
+
+    return "".join(block.text for block in response.content if block.type == "text").strip()
+
+# ── Main Loop ───────────────────────────────────────────────────────────────
+
+def run_qa_chat(issue_context, messenger, qa_name):
+    proxy_url = os.environ.get("CODER_PROXY_URL")
+    if proxy_url:
+        client = anthropic.Anthropic(base_url=proxy_url.rstrip('/'))
+    else:
+        client = anthropic.Anthropic()
+    conversation = []
+    raw_responses = []
+
+    log(f"Opening chat with {qa_name}...")
+
+    messenger.connect()
+
+    try:
+        messenger.navigate_to_chat(qa_name)
+
+        # Split enriched questions into separate messages
+        initial_msg = issue_context["enriched_questions"]
+        parts = split_questions(initial_msg)
+        for i, part in enumerate(parts):
+            messenger.send_message(part)
+            log(f"  Sent message {i + 1}/{len(parts)}")
+            time.sleep(1)
+        conversation.append({"from": "bot", "text": initial_msg})
+        log("Sent initial questions to QA")
+
+        rounds = 0
+        for round_num in range(1, MAX_ROUNDS + 1):
+            log(f"Round {round_num}/{MAX_ROUNDS}: waiting for QA...")
+            response_text = messenger.wait_for_response()
+            conversation.append({"from": "qa", "text": response_text})
+            raw_responses.append(response_text)
+            rounds = round_num
+            log(f"Round {round_num}: QA responded ({len(response_text)} chars)")
+
+            evaluation = evaluate_response(client, conversation, issue_context)
+            log(f"Round {round_num}: sufficient={evaluation['sufficient']} — {evaluation.get('reasoning', '')[:100]}")
+
+            if evaluation["sufficient"]:
+                break
+
+            if round_num < MAX_ROUNDS:
+                follow_up = evaluation.get("follow_up", "")
+                if follow_up:
+                    parts = split_questions(follow_up)
+                    for part in parts:
+                        messenger.send_message(part)
+                        time.sleep(1)
+                    conversation.append({"from": "bot", "text": follow_up})
+                    log(f"Round {round_num}: sent follow-up ({len(parts)} messages)")
+                else:
+                    log(f"Round {round_num}: no follow-up generated, stopping")
+                    break
+
+    finally:
+        messenger.close()
+
+    # Synthesize requirements from full conversation
+    log("Synthesizing requirements...")
+    requirements = synthesize(client, conversation, issue_context)
+
+    return {
+        "completed": True,
+        "requirements": requirements,
+        "conversation_rounds": rounds,
+        "raw_responses": raw_responses,
+    }
+
+# ── CLI ─────────────────────────────────────────────────────────────────────
+
+def main():
+    parser = argparse.ArgumentParser(description="QA Chat — multi-turn QA conversation tool")
+    parser.add_argument("--messenger", choices=["teams", "slack"], default="teams",
+                        help="Messenger to use for QA chat (default: teams)")
+    parser.add_argument("--auth", help="Path to Teams auth state JSON (required for --messenger teams)")
+    parser.add_argument("--qa", required=True, help="QA person's name")
+    parser.add_argument("--super", action="store_true", help="Use Opus 4.6 instead of Sonnet")
+    args = parser.parse_args()
+
+    if args.super:
+        global MODEL
+        MODEL = "claude-opus-4-6"
+        log(f"Super mode: using {MODEL}")
+
+    if not os.environ.get("ANTHROPIC_API_KEY"):
+        log("Error: ANTHROPIC_API_KEY not set")
+        sys.exit(1)
+
+    # Build the appropriate messenger
+    if args.messenger == "teams":
+        if not args.auth:
+            log("Error: --auth is required when using --messenger teams")
+            sys.exit(1)
+        messenger = TeamsMessenger(args.auth)
+    elif args.messenger == "slack":
+        slack_token = os.environ.get("SLACK_BOT_TOKEN", "")
+        if not slack_token:
+            log("Error: SLACK_BOT_TOKEN environment variable is required for --messenger slack")
+            sys.exit(1)
+        messenger = SlackMessenger(slack_token)
+
+    # Read issue context from stdin
+    try:
+        issue_context = json.load(sys.stdin)
+    except json.JSONDecodeError as e:
+        log(f"Error: invalid JSON on stdin: {e}")
+        sys.exit(1)
+
+    for key in ("issue_number", "issue_title", "enriched_questions"):
+        if key not in issue_context:
+            log(f"Error: missing required field '{key}' in input JSON")
+            sys.exit(1)
+
+    try:
+        result = run_qa_chat(issue_context, messenger, args.qa)
+        print(json.dumps(result, indent=2))
+    except KeyboardInterrupt:
+        print(json.dumps({
+            "completed": False,
+            "requirements": "",
+            "conversation_rounds": 0,
+            "raw_responses": [],
+            "error": "Interrupted by user",
+        }, indent=2))
+        sys.exit(130)
+    except Exception as e:
+        if is_token_limit_error(e):
+            log("Token limit reached — stopping.")
+        else:
+            log(f"Fatal error: {e}")
+        print(json.dumps({
+            "completed": False,
+            "requirements": "",
+            "conversation_rounds": 0,
+            "raw_responses": [],
+            "error": str(e),
+        }, indent=2))
+        sys.exit(1)
+
+
+if __name__ == "__main__":
+    main()

package/tools/requirements.txt

@@ -0,0 +1,3 @@
+anthropic>=0.40.0
+playwright
+slack_sdk>=3.27.0