Merge pull request #91 from nforro/fixes

Several fixes

Author: nforro

beeai/agents/backport_agent.py

@@ -1,11 +1,9 @@
 import asyncio
 import logging
 import os
-from shutil import rmtree
 import subprocess
 import sys
 import traceback
-
 from pathlib import Path
 
 from pydantic import BaseModel, Field
@@ -50,7 +48,6 @@ class InputSchema(BaseModel):
 class OutputSchema(BaseModel):
     success: bool = Field(description="Whether the backport was successfully completed")
     status: str = Field(description="Backport status")
-    mr_url: str | None = Field(description="URL to the opened merge request")
     error: str | None = Field(description="Specific details about an error")
 
 
@@ -78,7 +75,6 @@ async def main() -> None:
     logging.basicConfig(level=logging.INFO)
 
     setup_observability(os.environ["COLLECTOR_ENDPOINT"])
-    cve_id = os.getenv("CVE_ID", "")
 
     async with mcp_tools(os.environ["MCP_GATEWAY_URL"]) as gateway_tools:
         backport_agent = RequirementAgent(
@@ -117,6 +113,8 @@ async def main() -> None:
             ],
         )
 
+        dry_run = os.getenv("DRY_RUN", "False").lower() == "true"
+
         class State(BaseModel):
             jira_issue: str
             package: str
@@ -173,7 +171,7 @@ async def run_backport_agent(state):
             if state.backport_result.success:
                 return "commit_push_and_open_mr"
             else:
-                return Workflow.END
+                return "comment_in_jira"
 
         async def commit_push_and_open_mr(state):
             state.merge_request_url = await tasks.commit_push_and_open_mr(
@@ -186,13 +184,29 @@ async def commit_push_and_open_mr(state):
                 mr_title="{COMMIT_PREFIX} backport {state.jira_issue}",
                 mr_description="TODO",
                 available_tools=gateway_tools,
-                commit_only=os.getenv("DRY_RUN", "False").lower() == "true",
+                commit_only=dry_run,
+            )
+            return "comment_in_jira"
+
+        async def comment_in_jira(state):
+            if dry_run:
+                return Workflow.END
+            await tasks.comment_in_jira(
+                jira_issue=state.jira_issue,
+                agent_type="Backport",
+                comment_text=(
+                    state.merge_request_url
+                    if state.backport_result.success
+                    else f"Agent failed to perform a backport: {state.backport_result.error}"
+                ),
+                available_tools=gateway_tools,
             )
             return Workflow.END
 
         workflow.add_step("fork_and_prepare_dist_git", fork_and_prepare_dist_git)
         workflow.add_step("run_backport_agent", run_backport_agent)
         workflow.add_step("commit_push_and_open_mr", commit_push_and_open_mr)
+        workflow.add_step("comment_in_jira", comment_in_jira)
 
         async def run_workflow(package, dist_git_branch, upstream_fix, jira_issue, cve_id):
             response = await workflow.run(
@@ -280,31 +294,17 @@ async def retry(task, error):
                         f"Backport processing completed for {backport_data.jira_issue}, " f"success: {state.backport_result.success}"
                     )
 
-                    agent_type = "Backport"
-                    if state.backport_result.success:
-                        logger.info(f"Updating JIRA {backport_data.jira_issue} with {state.backport_result.mr_url} ")
-
-                        await post_private_jira_comment(gateway_tools, backport_data.jira_issue, agent_type, state.backport_result.mr_url)
-                    else:
-                        logger.info(f"Agent failed to perform a backport for {backport_data.jira_issue}.")
-                        await post_private_jira_comment(gateway_tools, backport_data.jira_issue, agent_type,
-                                                        "Agent failed to perform a backport: {state.backport_result.error}")
-
-
-
                 except Exception as e:
                     error = "".join(traceback.format_exception(e))
                     logger.error(f"Exception during backport processing for {backport_data.jira_issue}: {error}")
                     await retry(task, ErrorData(details=error, jira_issue=backport_data.jira_issue).model_dump_json())
-                    rmtree(local_clone)
                 else:
-                    rmtree(local_clone)
-                    if state.backport_data.success:
+                    if state.backport_result.success:
                         logger.info(f"Backport successful for {backport_data.jira_issue}, " f"adding to completed list")
-                        await redis.lpush("completed_backport_list", output.model_dump_json())
+                        await redis.lpush("completed_backport_list", state.backport_result.model_dump_json())
                     else:
-                        logger.warning(f"Backport failed for {backport_data.jira_issue}: {state.backport_data.error}")
-                        await retry(task, state.backport_data.error)
+                        logger.warning(f"Backport failed for {backport_data.jira_issue}: {state.backport_result.error}")
+                        await retry(task, state.backport_result.error)
 
 
 if __name__ == "__main__":

beeai/agents/rebase_agent.py

@@ -44,7 +44,6 @@ class InputSchema(BaseModel):
 class OutputSchema(BaseModel):
     success: bool = Field(description="Whether the rebase was successfully completed")
     status: str = Field(description="Rebase status")
-    mr_url: str | None = Field(description="URL to the opened merge request")
     error: str | None = Field(description="Specific details about an error")
 
 
@@ -132,6 +131,8 @@ async def main() -> None:
             ],
         )
 
+        dry_run = os.getenv("DRY_RUN", "False").lower() == "true"
+
         class State(BaseModel):
             jira_issue: str
             package: str
@@ -178,7 +179,7 @@ async def run_rebase_agent(state):
             if state.rebase_result.success:
                 return "commit_push_and_open_mr"
             else:
-                return Workflow.END
+                return "comment_in_jira"
 
         async def commit_push_and_open_mr(state):
             state.merge_request_url = await tasks.commit_push_and_open_mr(
@@ -191,13 +192,29 @@ async def commit_push_and_open_mr(state):
                 mr_title=f"{COMMIT_PREFIX} Update to version {state.version}",
                 mr_description="TODO",
                 available_tools=gateway_tools,
-                commit_only=os.getenv("DRY_RUN", "False").lower() == "true",
+                commit_only=dry_run,
+            )
+            return "comment_in_jira"
+
+        async def comment_in_jira(state):
+            if dry_run:
+                return Workflow.END
+            await tasks.comment_in_jira(
+                jira_issue=state.jira_issue,
+                agent_type="Rebase",
+                comment_text=(
+                    state.merge_request_url
+                    if state.rebase_result.success
+                    else f"Agent failed to perform a rebase: {state.rebase_result.error}"
+                ),
+                available_tools=gateway_tools,
             )
             return Workflow.END
 
         workflow.add_step("fork_and_prepare_dist_git", fork_and_prepare_dist_git)
         workflow.add_step("run_rebase_agent", run_rebase_agent)
         workflow.add_step("commit_push_and_open_mr", commit_push_and_open_mr)
+        workflow.add_step("comment_in_jira", comment_in_jira)
 
         async def run_workflow(package, dist_git_branch, version, jira_issue):
             response = await workflow.run(
@@ -282,15 +299,6 @@ async def retry(task, error):
                         f"Rebase processing completed for {rebase_data.jira_issue}, " f"success: {state.rebase_result.success}"
                     )
 
-                    agent_type = "Rebase"
-                    if state.rebase_result.success:
-                        logger.info(f"Updating JIRA {rebase_data.jira_issue} with {state.rebase_result.mr_url} ")
-                        await post_private_jira_comment(gateway_tools, rebase_data.jira_issue, agent_type, state.rebase_result.mr_url)
-                    else:
-                        logger.info(f"Agent failed to perform a rebase for {rebase_data.jira_issue}.")
-                        await post_private_jira_comment(gateway_tools, rebase_data.jira_issue, agent_type,
-                                                        "Agent failed to perform a rebase: {state.rebase_result.error}")
-
                 except Exception as e:
                     error = "".join(traceback.format_exception(e))
                     logger.error(f"Exception during rebase processing for {rebase_data.jira_issue}: {error}")

beeai/agents/tasks.py

@@ -7,7 +7,7 @@
 
 from beeai_framework.tools import Tool
 
-from constants import BRANCH_PREFIX
+from constants import BRANCH_PREFIX, JIRA_COMMENT_TEMPLATE
 from utils import check_subprocess, run_tool
 
 
@@ -73,3 +73,18 @@ async def commit_push_and_open_mr(
         source=update_branch,
         available_tools=available_tools,
     )
+
+
+async def comment_in_jira(
+    jira_issue: str,
+    agent_type: str,
+    comment_text: str,
+    available_tools: list[Tool],
+) -> None:
+    await run_tool(
+        "add_jira_comment",
+        issue_key=jira_issue,
+        comment=JIRA_COMMENT_TEMPLATE.substitute(AGENT_TYPE=agent_type, JIRA_COMMENT=comment_text),
+        private=True,
+        available_tools=available_tools,
+    )

beeai/agents/triage_agent.py

@@ -23,11 +23,12 @@
 from beeai_framework.tools.think import ThinkTool
 from beeai_framework.workflows import Workflow
 
+import tasks
 from observability import setup_observability
 from tools.commands import RunShellCommandTool
 from tools.patch_validator import PatchValidatorTool
 from tools.version_mapper import VersionMapperTool
-from utils import fix_await, get_agent_execution_config, mcp_tools, redis_client, post_private_jira_comment, run_tool
+from utils import fix_await, get_agent_execution_config, mcp_tools, redis_client, run_tool
 
 logger = logging.getLogger(__name__)
 
@@ -329,6 +330,8 @@ async def main() -> None:
             ]
         )
 
+        dry_run = os.getenv("DRY_RUN", "False").lower() == "true"
+
         class State(BaseModel):
             jira_issue: str
             cve_eligibility_result: dict | None = Field(default=None)
@@ -360,7 +363,7 @@ async def check_cve_eligibility(state):
                         jira_issue=state.jira_issue
                     )
                 )
-                return Workflow.END
+                return "comment_in_jira"
 
             reason = state.cve_eligibility_result.get('reason', 'Eligible')
             logger.info(f"Issue {state.jira_issue} is eligible for triage: {reason}")
@@ -379,6 +382,8 @@ async def run_triage_analysis(state):
 
             if state.triage_result.resolution in [Resolution.REBASE, Resolution.BACKPORT]:
                 return "determine_target_branch"
+            elif state.triage_result.resolution in [Resolution.CLARIFICATION_NEEDED, Resolution.NO_ACTION]:
+                return "comment_in_jira"
             else:
                 return Workflow.END
 
@@ -398,9 +403,25 @@ async def determine_target_branch_step(state):
 
             return Workflow.END
 
+        async def comment_in_jira(state):
+            if dry_run:
+                return Workflow.END
+            await tasks.comment_in_jira(
+                jira_issue=state.jira_issue,
+                agent_type="Triage",
+                comment_text=(
+                    state.triage_result.data.additional_info_needed
+                    if state.triage_result.resolution == Resolution.CLARIFICATION_NEEDED
+                    else state.triage_result.data.reasoning
+                ),
+                available_tools=gateway_tools,
+            )
+            return Workflow.END
+
         workflow.add_step("check_cve_eligibility", check_cve_eligibility)
         workflow.add_step("run_triage_analysis", run_triage_analysis)
         workflow.add_step("determine_target_branch", determine_target_branch_step)
+        workflow.add_step("comment_in_jira", comment_in_jira)
 
         async def run_workflow(jira_issue):
             response = await workflow.run(State(jira_issue=jira_issue))
@@ -465,12 +486,6 @@ async def retry(task, error):
                     if state.target_branch:
                         logger.info(f"Target branch: {state.target_branch}")
 
-                    agent_type = "Triage"
-                    if output.resolution.value == "clarification-needed":
-                        await post_private_jira_comment(gateway_tools, input.issue, agent_type, output.data.additional_info_needed)
-                    elif output.resolution.value == "no-action":
-                        await post_private_jira_comment(gateway_tools, input.issue, agent_type, output.data.reasoning)
-                        
                 except Exception as e:
                     error = "".join(traceback.format_exception(e))
                     logger.error(f"Exception during triage processing for {input.issue}: {error}")

beeai/agents/utils.py

@@ -18,7 +18,6 @@
 from beeai_framework.tools import Tool
 from beeai_framework.tools.mcp import MCPTool
 
-from constants import JIRA_COMMENT_TEMPLATE
 
 def get_agent_execution_config() -> AgentExecutionConfig:
     return AgentExecutionConfig(
@@ -127,25 +126,3 @@ async def mcp_tools(
         if filter:
             tools = [t for t in tools if filter(t.name)]
         yield tools
-
-async def post_private_jira_comment(gateway_tools: list, issue_key: str, agent_type: str, comment: str):
-    """Finds the Jira comment tool and posts a comment to the specified issue."""
-
-    logger = logging.getLogger(__name__)
-
-    dry_run = os.getenv("DRY_RUN", "False").lower() == "true"
-
-    if not dry_run:
-        try:
-            comment_tool = next(t for t in gateway_tools if t.name == "add_private_jira_comment")
-            await comment_tool.run(
-                input={
-                    "issue_key": issue_key,
-                    "comment": JIRA_COMMENT_TEMPLATE.substitute({"AGENT_TYPE": agent_type,
-                                                                 "JIRA_COMMENT": comment}),
-                }
-            ).middleware(GlobalTrajectoryMiddleware(pretty=True))
-        except StopIteration:
-            logger.error("Jira comment tool not found in gateway tools.")
-        except Exception as e:
-            logger.error(f"Failed to post Jira comment for issue {issue_key}: {e}")

beeai/compose.yaml

@@ -47,7 +47,7 @@ services:
       - .secrets/mcp-gateway.env
     volumes:
       - ./mcp_server:/home/mcp/mcp_server:ro,z
-      - .secrets/keytab:/home/mcp/keytab:ro,z
+      - .secrets/keytab:/home/mcp/keytab:ro,z,U
       - git-repos:/git-repos
       - .secrets/rhel-config.json:/home/mcp/rhel-config.json:ro,z,U
     command: ["python", "mcp_server/gateway.py"]

beeai/mcp_server/gateway.py

@@ -21,4 +21,4 @@
 
 
 if __name__ == "__main__":
-    mcp.run(transport="sse", host="0.0.0.0", port=os.getenv("SSE_PORT"))
+    mcp.run(transport="sse", host="0.0.0.0", port=int(os.getenv("SSE_PORT", "8000")))

beeai/mcp_server/jira_tools.py

@@ -142,36 +142,18 @@ def set_jira_fields(
 def add_jira_comment(
     issue_key: Annotated[str, Field(description="Jira issue key (e.g. RHEL-12345)")],
     comment: Annotated[str, Field(description="Comment text to add")],
+    private: Annotated[bool, Field(description="Whether the comment should be hidden from public")] = False,
 ) -> str:
     """
     Adds a comment to the specified Jira issue.
     """
     try:
         response = requests.post(
             urljoin(os.getenv("JIRA_URL"), f"rest/api/2/issue/{issue_key}/comment"),
-            json={"body": comment},
-            headers=_get_jira_headers(os.getenv("JIRA_TOKEN")),
-        )
-        response.raise_for_status()
-    except requests.RequestException as e:
-        return f"Failed to add the specified comment: {e}"
-    return f"Successfully added the specified comment to {issue_key}"
-
-def add_private_jira_comment(
-    issue_key: Annotated[str, Field(description="Jira issue key (e.g. RHEL-12345)")],
-    comment: Annotated[str, Field(description="Comment text to add")],
-) -> str:
-    """
-    Adds a private comment to the specified Jira issue.
-    """
-
-    if os.getenv("DRY_RUN", "False").lower() == "true":
-        return "Dry run, not adding private comment"
-
-    try:
-        response = requests.post(
-            urljoin(os.getenv("JIRA_URL"), f"rest/api/2/issue/{issue_key}/comment"),
-            json={"body": comment, "visibility": {"type":"group", "value":"Red Hat Employee"}},
+            json={
+                "body": comment,
+                **({"visibility": {"type": "group", "value": "Red Hat Employee"}} if private else {}),
+            },
             headers=_get_jira_headers(os.getenv("JIRA_TOKEN")),
         )
         response.raise_for_status()