@openhands/extensions 0.0.1-alpha → 0.2.0

package/plugins/release-notes/scripts/agent_script.py

@@ -0,0 +1,292 @@
+#!/usr/bin/env python3
+"""Generate release notes with an OpenHands agent.
+
+This script collects structured release metadata from GitHub, then asks an
+OpenHands agent to make editorial decisions about which changes matter, which
+PRs belong together, and how to phrase the final release notes.
+
+Environment Variables:
+    LLM_API_KEY: API key for the LLM (required)
+    LLM_MODEL: Language model to use
+    LLM_BASE_URL: Optional base URL for custom LLM endpoints
+    GITHUB_TOKEN: GitHub token for API access (required)
+    TAG: The release tag to generate notes for (required)
+    PREVIOUS_TAG: Override automatic detection of previous release (optional)
+    INCLUDE_INTERNAL: Include internal/infrastructure changes (default: false)
+    OUTPUT_FORMAT: Output format - 'release' or 'changelog' (default: release)
+    REPO_NAME: Repository name in format owner/repo (required)
+"""
+
+from __future__ import annotations
+
+import os
+import re
+import sys
+from pathlib import Path
+from typing import Any
+
+from openhands.sdk import LLM, Agent, AgentContext, Conversation, get_logger
+from openhands.sdk.skills import load_project_skills
+from openhands.sdk.conversation import get_agent_final_response
+from openhands.tools.preset.default import get_default_condenser, get_default_tools
+
+script_dir = Path(__file__).parent
+sys.path.insert(0, str(script_dir))
+
+from generate_release_notes import Change, ReleaseNotes, generate_release_notes, set_github_output  # noqa: E402
+from prompt import format_prompt  # noqa: E402
+from validate_release_notes import append_reference_coverage_appendix  # noqa: E402
+
+logger = get_logger(__name__)
+
+CATEGORY_ORDER = ["breaking", "features", "fixes", "docs", "internal", "other"]
+
+
+def _get_required_env(name: str) -> str:
+    value = os.getenv(name)
+    if not value:
+        raise ValueError(f"{name} environment variable is required")
+    return value
+
+
+def _get_bool_env(name: str, default: bool = False) -> bool:
+    value = os.getenv(name)
+    if value is None:
+        return default
+    return value.lower() == "true"
+
+
+def validate_environment() -> dict[str, Any]:
+    """Validate required environment variables and return configuration."""
+    return {
+        "model": os.getenv("LLM_MODEL", "anthropic/claude-sonnet-4-5-20250929"),
+        "base_url": os.getenv("LLM_BASE_URL", ""),
+        "api_key": _get_required_env("LLM_API_KEY"),
+        "github_token": _get_required_env("GITHUB_TOKEN"),
+        "tag": _get_required_env("TAG"),
+        "previous_tag": os.getenv("PREVIOUS_TAG") or None,
+        "include_internal": _get_bool_env("INCLUDE_INTERNAL", False),
+        "output_format": os.getenv("OUTPUT_FORMAT", "release"),
+        "repo_name": _get_required_env("REPO_NAME"),
+    }
+
+
+def create_agent(config: dict[str, Any]) -> Agent:
+    """Create and configure the release-notes agent."""
+    llm_config: dict[str, Any] = {
+        "model": config["model"],
+        "api_key": config["api_key"],
+        "usage_id": "release_notes_agent",
+        "drop_params": True,
+    }
+    if config["base_url"]:
+        llm_config["base_url"] = config["base_url"]
+
+    llm = LLM(**llm_config)
+
+    cwd = os.getcwd()
+    project_skills = load_project_skills(cwd)
+    logger.info(
+        "Loaded %s project skills: %s",
+        len(project_skills),
+        [skill.name for skill in project_skills],
+    )
+
+    agent_context = AgentContext(
+        load_public_skills=False,
+        skills=project_skills,
+    )
+
+    return Agent(
+        llm=llm,
+        tools=get_default_tools(enable_browser=False),
+        agent_context=agent_context,
+        system_prompt_kwargs={"cli_mode": True},
+        condenser=get_default_condenser(
+            llm=llm.model_copy(update={"usage_id": "release_notes_condenser"})
+        ),
+    )
+
+
+def _truncate(text: str, limit: int = 280) -> str:
+    compact = re.sub(r"\s+", " ", text or "").strip()
+    if len(compact) <= limit:
+        return compact
+    return compact[: limit - 1].rstrip() + "…"
+
+
+def _format_change_block(change: Change, repo_name: str) -> str:
+    pr_ref = f"#{change.pr_number}" if change.pr_number else change.sha[:7]
+    labels = ", ".join(change.pr_labels) if change.pr_labels else "none"
+    url = change.url or (
+        f"https://github.com/{repo_name}/pull/{change.pr_number}"
+        if change.pr_number
+        else f"https://github.com/{repo_name}/commit/{change.sha}"
+    )
+    body = _truncate(change.body, 400) or "No PR body provided"
+
+    return "\n".join(
+        [
+            f"- Ref: {pr_ref}",
+            f"  Title: {change.message}",
+            f"  Author: @{change.author}" if change.author else "  Author: unknown",
+            f"  Suggested category: {change.category}",
+            f"  Labels: {labels}",
+            f"  URL: {url}",
+            f"  Body: {body}",
+        ]
+    )
+
+
+def build_change_candidates(notes: ReleaseNotes) -> str:
+    """Build the structured candidate change list for the agent prompt."""
+    lines: list[str] = []
+    for category in CATEGORY_ORDER:
+        changes = notes.changes.get(category, [])
+        if not changes:
+            continue
+        lines.append(f"\nSuggested {category}:" )
+        for change in changes:
+            lines.append(_format_change_block(change, notes.repo_name))
+    return "\n".join(lines).strip()
+
+
+def build_new_contributors(notes: ReleaseNotes) -> str:
+    """Build the new-contributors section for the agent prompt."""
+    if not notes.new_contributors:
+        return "- None"
+
+    lines = []
+    for contributor in notes.new_contributors:
+        pr_text = f" in #{contributor.first_pr}" if contributor.first_pr else ""
+        lines.append(f"- @{contributor.username} made their first contribution{pr_text}")
+    return "\n".join(lines)
+
+
+def extract_markdown(text: str) -> str:
+    """Normalize the agent response into plain markdown."""
+    cleaned = text.strip()
+    fence_match = re.fullmatch(r"```(?:markdown)?\s*\n?(.*?)\n?```", cleaned, re.DOTALL)
+    if fence_match:
+        cleaned = fence_match.group(1).strip()
+    return cleaned
+
+
+def build_prompt(notes: ReleaseNotes, include_internal: bool, output_format: str) -> str:
+    """Build the prompt sent to the release-notes agent."""
+    return format_prompt(
+        repo_name=notes.repo_name,
+        tag=notes.tag,
+        previous_tag=notes.previous_tag,
+        date=notes.date,
+        commit_count=notes.commit_count,
+        include_internal=include_internal,
+        output_format=output_format,
+        full_changelog_url=(
+            f"https://github.com/{notes.repo_name}/compare/"
+            f"{notes.previous_tag}...{notes.tag}"
+        ),
+        change_candidates=build_change_candidates(notes),
+        new_contributors=build_new_contributors(notes),
+    )
+
+
+def run_generation(
+    agent: Agent,
+    prompt: str,
+    secrets: dict[str, str],
+) -> tuple[Conversation, str]:
+    """Run the agent and return the conversation plus generated markdown."""
+    conversation = Conversation(
+        agent=agent,
+        workspace=os.getcwd(),
+        secrets=secrets,
+    )
+
+    logger.info("Starting agent-based release note generation...")
+    conversation.send_message(prompt)
+    conversation.run()
+
+    response = get_agent_final_response(conversation.state.events)
+    if not response:
+        raise RuntimeError("Agent did not return release notes")
+
+    return conversation, extract_markdown(response)
+
+
+def log_cost_summary(conversation: Conversation) -> None:
+    """Print cost information for CI output."""
+    metrics = conversation.conversation_stats.get_combined_metrics()
+    print("\n=== Release Notes Cost Summary ===")
+    print(f"Total Cost: ${metrics.accumulated_cost:.6f}")
+    if metrics.accumulated_token_usage:
+        token_usage = metrics.accumulated_token_usage
+        print(f"Prompt Tokens: {token_usage.prompt_tokens}")
+        print(f"Completion Tokens: {token_usage.completion_tokens}")
+        if token_usage.cache_read_tokens > 0:
+            print(f"Cache Read Tokens: {token_usage.cache_read_tokens}")
+        if token_usage.cache_write_tokens > 0:
+            print(f"Cache Write Tokens: {token_usage.cache_write_tokens}")
+
+
+def main() -> None:
+    """Generate release notes with an agent and write outputs for GitHub Actions."""
+    config = validate_environment()
+
+    logger.info("Generating release notes for %s", config["repo_name"])
+    logger.info("Tag: %s", config["tag"])
+    logger.info("Previous tag: %s", config["previous_tag"] or "auto-detect")
+    logger.info("Include internal: %s", config["include_internal"])
+    logger.info("Output format: %s", config["output_format"])
+    logger.info("LLM model: %s", config["model"])
+
+    notes = generate_release_notes(
+        tag=config["tag"],
+        previous_tag=config["previous_tag"],
+        repo_name=config["repo_name"],
+        token=config["github_token"],
+        include_internal=config["include_internal"],
+    )
+
+    prompt = build_prompt(
+        notes=notes,
+        include_internal=config["include_internal"],
+        output_format=config["output_format"],
+    )
+
+    agent = create_agent(config)
+    conversation, markdown = run_generation(
+        agent=agent,
+        prompt=prompt,
+        secrets={
+            "LLM_API_KEY": config["api_key"],
+            "GITHUB_TOKEN": config["github_token"],
+        },
+    )
+    markdown = append_reference_coverage_appendix(
+        markdown,
+        notes,
+        include_internal=config["include_internal"],
+    )
+
+    with open("release_notes.md", "w") as file:
+        file.write(markdown)
+
+    print("\n" + "=" * 60)
+    print("Generated Release Notes:")
+    print("=" * 60)
+    print(markdown)
+    print("=" * 60)
+
+    set_github_output("release_notes", markdown)
+    set_github_output("previous_tag", notes.previous_tag)
+    set_github_output("commit_count", str(notes.commit_count))
+    set_github_output("contributor_count", str(len(notes.contributors)))
+    set_github_output("new_contributor_count", str(len(notes.new_contributors)))
+
+    log_cost_summary(conversation)
+    logger.info("Release notes generated successfully")
+
+
+if __name__ == "__main__":
+    main()