Merge pull request #122 from MLAI-AUS-Inc/codex/domain-scan-routing-fix

bugfix publish to PR

Author: drsamdonegan

roo-standalone/roo/agent.py

@@ -17,7 +17,7 @@
 from .slack_client import get_thread_messages
 
 
-THREAD_CONTEXT_TTL = timedelta(minutes=20)
+THREAD_CONTEXT_TTL = timedelta(hours=2)
 
 
 class RooAgent:

roo-standalone/roo/clients/mlai_backend.py

@@ -962,6 +962,38 @@ async def publish_article_as_pr(self, job_id: str, slack_user_id: str) -> dict:
             response.raise_for_status()
             return response.json()
 
+    async def resolve_content_thread(
+        self,
+        *,
+        slack_user_id: str,
+        slack_channel_id: str,
+        slack_thread_ts: str,
+        requested_action: str,
+        domain: Optional[str] = None,
+    ) -> dict:
+        """Resolve the active content-factory job for a Slack thread."""
+        if not self.base_url:
+            raise ValueError("MLAI_BACKEND_URL not configured")
+
+        payload = {
+            "slack_user_id": self._clean_slack_id(slack_user_id),
+            "slack_channel_id": slack_channel_id,
+            "slack_thread_ts": slack_thread_ts,
+            "requested_action": requested_action,
+        }
+        if domain:
+            payload["domain"] = domain
+
+        async with httpx.AsyncClient() as client:
+            response = await client.post(
+                f"{self.base_url}/api/v1/content/jobs/resolve-thread",
+                json=payload,
+                headers=self.headers,
+                timeout=30.0,
+            )
+            response.raise_for_status()
+            return response.json()
+
     # =========================================================================
     # Missing Admin / Points Methods
     # =========================================================================

roo-standalone/roo/main.py

@@ -2072,6 +2072,93 @@ async def slack_actions(request: Request):
         ))
         return JSONResponse(status_code=200, content={})
 
+    if action_id == "publish_content_pr":
+        value = actions[0].get("value", "")
+        try:
+            value_data = json.loads(value) if value else {}
+        except json.JSONDecodeError:
+            value_data = {}
+
+        job_id = str(value_data.get("job_id") or "").strip()
+        domain = value_data.get("domain")
+        original_user_id = value_data.get("slack_user_id")
+        value_channel_id = value_data.get("channel_id")
+        value_thread_ts = value_data.get("thread_ts")
+
+        msg_channel = payload.get("channel", {}).get("id")
+        msg_ts = payload.get("message", {}).get("ts")
+        reply_channel = value_channel_id or channel_id or msg_channel
+        reply_thread_ts = value_thread_ts or payload.get("message", {}).get("thread_ts") or msg_ts
+
+        if user_id != original_user_id:
+            return JSONResponse(status_code=200, content={
+                "response_type": "ephemeral",
+                "text": "⚠️ Only the user who requested this article can publish it as a PR."
+            })
+
+        if not job_id:
+            if reply_channel:
+                post_message(
+                    channel=reply_channel,
+                    thread_ts=reply_thread_ts,
+                    text="⚠️ I couldn't determine which completed article bundle to publish from this button. Please use the original content-ready thread."
+                )
+            return JSONResponse(status_code=200, content={})
+
+        _remember_content_thread_context(
+            reply_channel,
+            reply_thread_ts,
+            domain,
+            "publish_pr",
+            active_job_id=job_id,
+        )
+
+        try:
+            from .slack_client import get_slack_client
+            slack_client = get_slack_client()
+            original_blocks = payload.get("message", {}).get("blocks", [])
+            updated_blocks = []
+            for block in original_blocks:
+                if block.get("block_id") == "content_ready_publish_actions":
+                    continue
+                if block.get("type") == "actions":
+                    elements = [
+                        element for element in block.get("elements", [])
+                        if element.get("action_id") != "publish_content_pr"
+                    ]
+                    if not elements:
+                        continue
+                    updated_blocks.append({**block, "elements": elements})
+                    continue
+                updated_blocks.append(block)
+            updated_blocks.append({
+                "type": "context",
+                "elements": [{"type": "mrkdwn", "text": "⏳ Publishing this article as a draft PR..."}]
+            })
+            slack_client.chat_update(
+                channel=msg_channel,
+                ts=msg_ts,
+                text=payload.get("message", {}).get("text", ""),
+                blocks=updated_blocks
+            )
+        except Exception as e:
+            print(f"⚠️ Failed to update publish-content-pr message: {e}")
+
+        asyncio.create_task(_handle_mention(
+            {
+                "user": user_id,
+                "text": "publish this article as a PR",
+                "channel": reply_channel,
+                "thread_ts": reply_thread_ts,
+                "param_overrides": {
+                    "action": "publish_pr",
+                    "job_id": job_id,
+                    "domain": domain,
+                },
+            }
+        ))
+        return JSONResponse(status_code=200, content={})
+
     # Handler for confirm_topic (new format)
     # Value format: "confirm:{keyword}:{job_id}"
     if action_id == "confirm_topic":

roo-standalone/roo/skills/executor.py

@@ -24,7 +24,7 @@
     is_free_content_factory_domain,
     normalize_content_factory_domain,
 )
-from ..content_intent import is_explicit_scan_request
+from ..content_intent import detect_content_action, is_explicit_scan_request
 from ..llm import chat, embed, get_llm_client
 from ..slack_client import post_message
 from ..config import get_settings
@@ -1372,6 +1372,76 @@ def _build_publish_pr_start_response(
             },
         }
 
+    async def _resolve_publish_pr_follow_up(
+        self,
+        api_client,
+        *,
+        text: str,
+        params: dict,
+        user_id: str,
+        channel_id: Optional[str],
+        thread_ts: Optional[str],
+    ) -> tuple[dict, Optional[Any]]:
+        requested_action = detect_content_action(text)
+        if requested_action != "publish_pr":
+            return params, None
+
+        existing_job_id = str(params.get("job_id") or "").strip()
+        if existing_job_id:
+            params["action"] = "publish_pr"
+            return params, None
+
+        if not channel_id or not thread_ts:
+            return params, (
+                "I couldn't identify a completed article bundle for this publish request because the Slack thread context was missing."
+            )
+
+        try:
+            resolution = await api_client.resolve_content_thread(
+                slack_user_id=user_id,
+                slack_channel_id=channel_id,
+                slack_thread_ts=thread_ts,
+                requested_action="publish_pr",
+                domain=params.get("domain"),
+            )
+        except httpx.HTTPStatusError as exc:
+            if exc.response.status_code == 404:
+                return params, (
+                    "I couldn't identify a completed article bundle to publish from this thread. "
+                    "Please use the original content-ready thread for the article you want to publish."
+                )
+            return params, f"❌ I couldn't resolve which completed article to publish from this thread: {exc}"
+        except Exception as exc:
+            return params, f"❌ I couldn't resolve which completed article to publish from this thread: {exc}"
+
+        resolution_type = str(resolution.get("resolution") or "").strip()
+        resolved_domain = (
+            normalize_content_factory_domain(resolution.get("domain"))
+            or params.get("domain")
+            or resolution.get("domain")
+        )
+        if resolution_type == "ready":
+            params["action"] = "publish_pr"
+            params["job_id"] = str(resolution.get("job_id") or "").strip()
+            if resolved_domain:
+                params["domain"] = resolved_domain
+            return params, None
+
+        if resolution_type == "in_progress":
+            publish_job_id = str(resolution.get("promoted_publish_job_id") or "").strip()
+            if not publish_job_id:
+                return params, (
+                    "I found an article in this thread that is already being promoted, but I couldn't determine the active publish run."
+                )
+            return params, self._build_publish_pr_start_response(
+                domain=resolved_domain,
+                job_id=publish_job_id,
+            )
+
+        return params, (
+            "I couldn't identify a completed article bundle to publish from this thread."
+        )
+
     def _get_connected_domain_info(
         self,
         connected_domains: List[dict],
@@ -1479,6 +1549,18 @@ async def _execute_content_factory(
         domain = params.get("domain")
         org_config_cached = None
         action = params.get("action")
+        params, publish_resolution = await self._resolve_publish_pr_follow_up(
+            api_client,
+            text=text,
+            params=params,
+            user_id=user_id,
+            channel_id=channel_id,
+            thread_ts=thread_ts,
+        )
+        if publish_resolution is not None:
+            return publish_resolution
+        action = params.get("action")
+        domain = params.get("domain")
         if action == "publish_pr":
             return await self._publish_content_bundle_as_pr(
                 api_client,