Change Slack plain text to Markdown format

DIFF.md

@@ -0,0 +1,313 @@
+diff --git a/.env b/.env
+new file mode 100644
+index 0000000..a392d55
+--- /dev/null
++++ b/.env
+@@ -0,0 +1,3 @@
++WORKSPACE_ID=thuantran_smulie
+
+diff --git a/.gitignore b/.gitignore
+index b24d71e..1a2f934 100644
+--- a/.gitignore
++++ b/.gitignore
+@@ -48,3 +48,4 @@ Thumbs.db
+ *.mov
+ *.wmv
+ 
++.env
+
+diff --git a/PR.md b/PR.md
+new file mode 100644
+index 0000000..8416126
+--- /dev/null
++++ b/PR.md
+@@ -0,0 +1,20 @@
++
++# [pr-code-review] PR #2: Upload change in README.md
++*Change documentation in README.md file*
++
++**🌿 Branch Information:**
++- **Source Branch:** feature/pull-request → **Target Branch:** main
++
++**👤 Người tạo:** Hai Huynh
++
++**📅 Thời gian tạo:** 2024-08-20 14:30:00 +07:00
++
++**👥 Reviewers:**
++None
++
++**🔗 Link Pull Request:** [PR #2: Implement user authentication system](https://bitbucket.org/thuantran_smulie/pr-code-review/pull-requests/2)
++
++---
++
++## 📝 Changelogs: 
++    
+
+diff --git a/README.md b/README.md
+index c0a0828..f32c700 100644
+--- a/README.md
++++ b/README.md
+@@ -1 +1,3 @@
+-Trigger khi có PR được tạo/thay đổi và gửi tin nhắn về Slack
+
++Trigger khi có PR được tạo/thay đổi và gửi tin nhắn về Slack
++Review code và gửi thông tin về Slack
++Gửi báo cáo về Slack
+diff --git a/bitbucket-pipelines.yml b/bitbucket-pipelines.yml
+index 35d5eb0..7206a5e 100644
+--- a/bitbucket-pipelines.yml
++++ b/bitbucket-pipelines.yml
+@@ -4,6 +4,42 @@ pipelines:
+       - step:
+           name: Build & Test on PR
+           script:
+-            - echo "Running build for PR"
+-            - npm install
+-            - npm test
++            - echo "=== PULL REQUEST INFORMATION ==="
++            - echo $BITBUCKET_PR_ID
++            - echo "=== BRANCH INFORMATION ==="
++            - echo $BITBUCKET_BRANCH
++            - echo $BITBUCKET_PR_DESTINATION_BRANCH
++            - echo "=== COMMIT INFORMATION ==="
++            - echo $BITBUCKET_COMMIT
++            - echo "=== REPOSITORY INFORMATION ==="
++            - echo $BITBUCKET_REPO_SLUG
++            - echo $BITBUCKET_REPO_UUID
++            - echo $BITBUCKET_WORKSPACE
++            - echo "=== PIPELINE INFORMATION ==="
++            - echo $BITBUCKET_PIPELINE_UUID
++            - echo $BITBUCKET_BUILD_NUMBER
++            - echo $BITBUCKET_STEP_UUID
++            - echo $BITBUCKET_STEP_NAME
++            - echo $BITBUCKET_STEP_RUN_NUMBER
++            - echo "=== ENVIRONMENT VARIABLES ==="
++            - echo "All PR-related environment variables:"
++            - env | grep BITBUCKET_PR
++            - echo "All Bitbucket environment variables:"
++            - env | grep BITBUCKET
++
++      - step:
++          name: Run Python Script
++          image: python:3.11
++          script:
++            - pip install -r requirements.txt
++            - echo "=== RUNNING TOOL SCRIPT ==="
++
++      - step:
++          name: Notify Slack
++          script:
++            - export MESSAGE="$(cat PR.md)"
++            - pipe: atlassian/slack-notify:2.3.1
++              variables:
++                WEBHOOK_URL: $SLACK_WEBHOOK_URL
++                MESSAGE: $MESSAGE
+
+diff --git a/requirements.txt b/requirements.txt
+new file mode 100644
+index 0000000..e6442c3
+--- /dev/null
++++ b/requirements.txt
+@@ -0,0 +1,2 @@
++dotenv
++requests
+
+diff --git a/tool.py b/tool.py
+new file mode 100644
+index 0000000..8062704
+--- /dev/null
++++ b/tool.py
+@@ -0,0 +1,201 @@
++import os
++import json
++import argparse
++from typing import Dict, Any, List, Optional, Tuple
++from dotenv import load_dotenv
++
++import requests
++
++# Set up ENVIRONMENT VARIABLE
++load_dotenv()
++# WORKSPACE_ID = os.getenv("WORKSPACE_ID")
++# BITBUCKET_USERNAME = os.getenv("BITBUCKET_USERNAME")
++DEFAULT_BASE_URL = "https://api.bitbucket.org/2.0"
++
++
++def create_session(username: Optional[str] = None, app_password: Optional[str] = None) -> requests.Session:
++    resolved_username = username or os.getenv("BITBUCKET_USERNAME")
++
++    if not resolved_username or not resolved_app_password:
++        raise ValueError(
++            "Missing credentials. Provide --username and --app-password or set env vars "
++        )
++
++    session = requests.Session()
++    session.auth = (resolved_username, resolved_app_password)
++    session.headers.update({"Accept": "application/json"})
++    return session
++
++
++def _request_json(session: requests.Session, method: str, url: str, params: Optional[Dict[str, Any]] = None) -> Dict[str, Any]:
++    response = session.request(method, url, params=params, timeout=30)
++    response.raise_for_status()
++    return response.json()
++
++
++def _paginate_all(session: requests.Session, url: str, params: Optional[Dict[str, Any]] = None) -> List[Dict[str, Any]]:
++    """
++    Retrieve all pages for Bitbucket v2.0 endpoints that return 'values' and 'next'.
++    """
++    aggregated_values: List[Dict[str, Any]] = []
++    next_url: Optional[str] = url
++    query_params: Dict[str, Any] = dict(params or {})
++    if "pagelen" not in query_params:
++        query_params["pagelen"] = 100
++
++    while next_url:
++        data = _request_json(session, "GET", next_url, params=query_params if next_url == url else None)
++        values = data.get("values", [])
++        aggregated_values.extend(values)
++        next_url = data.get("next")
++    return aggregated_values
++
++
++def get_pull_request_overview(session: requests.Session, workspace: str, repo_slug: str, pr_id: int, base_url: str = DEFAULT_BASE_URL) -> Dict[str, Any]:
++    url = f"{base_url}/repositories/{workspace}/{repo_slug}/pullrequests/{pr_id}"
++    return _request_json(session, "GET", url)
++
++
++def get_pull_request_commits(session: requests.Session, workspace: str, repo_slug: str, pr_id: int, base_url: str = DEFAULT_BASE_URL) -> List[Dict[str, Any]]:
++    url = f"{base_url}/repositories/{workspace}/{repo_slug}/pullrequests/{pr_id}/commits"
++    return _paginate_all(session, url)
++
++
++def get_pull_request_comments(session: requests.Session, workspace: str, repo_slug: str, pr_id: int, base_url: str = DEFAULT_BASE_URL) -> List[Dict[str, Any]]:
++    url = f"{base_url}/repositories/{workspace}/{repo_slug}/pullrequests/{pr_id}/comments"
++    return _paginate_all(session, url)
++
++
++def get_pull_request_activity(session: requests.Session, workspace: str, repo_slug: str, pr_id: int, base_url: str = DEFAULT_BASE_URL) -> List[Dict[str, Any]]:
++    url = f"{base_url}/repositories/{workspace}/{repo_slug}/pullrequests/{pr_id}/activity"
++    return _paginate_all(session, url)
++
++
++def get_pull_request_diff(session: requests.Session, workspace: str, repo_slug: str, pr_id: int, base_url: str = DEFAULT_BASE_URL) -> str:
++    """
++    Returns unified diff text for the PR. This endpoint returns text/plain.
++    """
++    url = f"{base_url}/repositories/{workspace}/{repo_slug}/pullrequests/{pr_id}/diff"
++    headers = {"Accept": "text/plain"}
++    response = session.get(url, headers=headers, timeout=60)
++    response.raise_for_status()
++    return response.text
++
++
++def get_pull_request_full_data(
++    session: requests.Session,
++    workspace: str,
++    repo_slug: str,
++    pr_id: int,
++    include: Optional[List[str]] = None,
++    base_url: str = DEFAULT_BASE_URL,
++) -> Dict[str, Any]:
++    """
++    Fetch a comprehensive view of a Bitbucket Cloud pull request:
++    - overview: PR metadata
++    - commits: all commits attached to the PR
++    - comments: all comments (including inline)
++    - activity: all activity events for the PR
++    - diff: unified diff text
++
++    'include' can limit which sections to fetch. Valid values: overview, commits, comments, activity, diff.
++    """
++    sections = ["overview", "commits", "comments", "activity", "diff"]
++
++    result: Dict[str, Any] = {}
++
++    if "overview" in sections:
++        result["overview"] = get_pull_request_overview(session, workspace, repo_slug, pr_id, base_url)
++    if "commits" in sections:
++        result["commits"] = get_pull_request_commits(session, workspace, repo_slug, pr_id, base_url)
++    if "comments" in sections:
++        result["comments"] = get_pull_request_comments(session, workspace, repo_slug, pr_id, base_url)
++    if "activity" in sections:
++        result["activity"] = get_pull_request_activity(session, workspace, repo_slug, pr_id, base_url)
++    if "diff" in sections:
++        result["diff"] = get_pull_request_diff(session, workspace, repo_slug, pr_id, base_url)
++
++    return result
++
++
++def save_md_report(filename, content):
++    with open(filename, "w", encoding="utf-8") as f:
++        f.write(content)
++        print(f"Saved {filename} file")
++
++def main() -> None:
++    parser = argparse.ArgumentParser(description="Fetch full details of a Bitbucket Cloud pull request.")
++    parser.add_argument("--username", required=True, help="Bitbucket username")
++    parser.add_argument("--password", required=True, help="Bitbucket app password")
++    parser.add_argument("--workspace", required=True, help="Bitbucket workspace ID or slug")
++    parser.add_argument("--repo", required=True, help="Repository slug")
++    parser.add_argument("--pr", required=True, type=int, help="Pull request ID")
++    # parser.add_argument("--username", help="Bitbucket username (or set BITBUCKET_USERNAME)")
++    # parser.add_argument(
++    #     "--include",
++    #     nargs="*",
++    #     choices=["overview", "commits", "comments", "activity", "diff"],
++    #     help="Sections to include. Default: all",
++    # )
++    # parser.add_argument("--base-url", default=DEFAULT_BASE_URL, help="Base API URL. Default is Bitbucket Cloud v2.0")
++    args = parser.parse_args()
++
++    session = create_session(args.username, args.password)
++
++    data = get_pull_request_overview(
++        session = session, 
++        workspace = args.workspace, 
++        repo_slug = args.repo, 
++        pr_id = args.pr, 
++        base_url = DEFAULT_BASE_URL
++    )
++
++    # Lấy các thông tin cần thiết
++    title = data["title"]
++    description = data["description"]
++    source_branch = data["source"]["branch"]["name"]
++    destination_branch = data["destination"]["branch"]["name"]
++    author = data["author"]["display_name"]
++    created_on = data["created_on"]
++    reviewers = data.get("reviewers", [])
++    reviewer_mentions = " ".join([f"@{r.get('nickname')}" for r in reviewers]) if reviewers else "None"
++    pr_link = data["links"]["html"]["href"]
++    changelog = data["summary"]["raw"]
++
++
++    pr_report = f"""
++# [{args.repo}] PR #{args.pr}: {title}
++*{description}*
++
++**🌿 Branch Information:**
++- **Source Branch:** {source_branch} → **Target Branch:** {destination_branch}
++
++**👤 Người tạo:** {author}
++
++**📅 Thời gian tạo:** 2024-08-20 14:30:00 +07:00
++
++**👥 Reviewers:**
++{reviewer_mentions}
++
++**🔗 Link Pull Request:** [PR #{args.pr}: Implement user authentication system]({pr_link})
++
++---
++
++## 📝 Changelogs: 
++    """
++
++    save_md_report("PR.md", pr_report)
++
++
++if __name__ == "__main__":
++    main()    
++
++

README.md

@@ -7,4 +7,67 @@ sdk: docker
 pinned: false
 ---
 
+# PR Webhook with Code Review Agent
+
+A webhook service that integrates with a code review agent powered by Pydantic AI and enhanced with Logfire tracing.
+
+## Features
+
+- **Code Review Agent**: Automated code review using Pydantic AI
+- **Logfire Tracing**: Comprehensive tracing and monitoring of agent runs
+- **Webhook Integration**: Handles pull request webhooks
+- **Structured Output**: Generates detailed code review reports
+
+## Setup
+
+### Environment Variables
+
+Create a `.env` file with the following variables:
+
+```bash
+# Logfire Configuration
+LOGFIRE_API_KEY=your_logfire_api_key_here
+
+# Code Review Model
+CODE_REVIEW_MODEL=google-gla:gemini-2.5-pro
+```
+
+### Installation
+
+```bash
+pip install -r requirements.txt
+```
+
+## Usage
+
+### Running the Agent
+
+```bash
+python agent/code_review.py
+```
+
+### Using the Webhook
+
+The service will automatically trace all agent runs with detailed metrics including:
+- Execution time
+- Input/output sizes
+- Error tracking
+- Performance metrics
+
+## Tracing Features
+
+The agent now includes comprehensive tracing with Logfire:
+
+- **Span Tracking**: Each major operation is wrapped in a tracing span
+- **Event Logging**: Key milestones are logged as events
+- **Error Handling**: Exceptions are automatically captured and traced
+- **Performance Metrics**: Input/output sizes and execution times are tracked
+- **Context Attributes**: Relevant metadata is attached to each span
+
+## Architecture
+
+- `agent/code_review.py`: Main code review agent with Logfire tracing
+- `index.py`: Webhook endpoint handler
+- `tool.py`: Utility functions and webhook processing
+
 Check out the configuration reference at https://huggingface.co/docs/hub/spaces-config-reference

agent/code_review.py

@@ -10,9 +10,16 @@ from typing import List, Optional, Dict, Iterable, Tuple
 from pydantic import BaseModel, Field
 from pydantic_ai import Agent, RunContext
 from dotenv import load_dotenv
+import logfire
 
 load_dotenv()
 
+# =============================
+# Logfire configuration for tracing
+# =============================
+logfire.configure(token = os.getenv('LOGFIRE_API_KEY'))
+logfire.instrument_pydantic_ai()
+
 # =============================
 # Data models for structured output
 # =============================
@@ -350,17 +357,49 @@ async def review_paths(
     focus_areas: Optional[List[str]] = None,
     model: Optional[str] = None,
 ) -> CodeReviewResponse:
-    files, dirs = gather_targets(paths)
-
-    agent = code_review_agent if model is None else Agent(
-        model=model,
-        result_model=CodeReviewResponse,
-        system_prompt=SYSTEM_PROMPT,
-    )
-
-    user_prompt = build_user_prompt(files, dirs, focus_areas or [])
-    run = await agent.run(user_prompt)
-    return run.data
+    # Start tracing span
+    with logfire_client.span("review_paths", attributes={
+        "paths_count": len(paths),
+        "focus_areas": focus_areas or [],
+        "model": model or "default"
+    }) as span:
+        try:
+            files, dirs = gather_targets(paths)
+            
+            # Log file analysis
+            span.add_event("files_analyzed", attributes={
+                "files_count": len(files),
+                "directories_count": len(dirs)
+            })
+            
+            agent = code_review_agent if model is None else Agent(
+                model=model,
+                result_model=CodeReviewResponse,
+                system_prompt=systemt_prompt, # Use the system prompt directly
+            )
+
+            user_prompt = build_user_prompt(files, dirs, focus_areas or [])
+            
+            # Log prompt generation
+            span.add_event("prompt_generated", attributes={
+                "prompt_length": len(user_prompt)
+            })
+            
+            run = await agent.run(user_prompt)
+            
+            # Log successful completion
+            span.add_event("review_completed", attributes={
+                "overall_score": run.data.overall_score,
+                "files_reviewed": len(run.data.files)
+            })
+            
+            return run.data
+            
+        except Exception as e:
+            # Log error
+            span.record_exception(e)
+            span.set_status(logfire.StatusCode.ERROR, str(e))
+            raise
 
 
 async def review_code_string(
@@ -369,18 +408,45 @@ async def review_code_string(
     focus_areas: Optional[List[str]] = None,
     model: Optional[str] = None,
 ) -> CodeReviewResponse:
-    agent = code_review_agent if model is None else Agent(
-        model=model,
-        result_model=CodeReviewResponse,
-        system_prompt=SYSTEM_PROMPT,
-    )
-    prompt = (
-        f"Review the following code ({filename}).\n\n"  # noqa: E501
-        f"Focus areas: {', '.join(focus_areas or []) or 'general quality'}.\n\n"
-        f"{code}"
-    )
-    run = await agent.run(prompt)
-    return run.data
+    # Start tracing span
+    with logfire_client.span("review_code_string", attributes={
+        "filename": filename,
+        "code_length": len(code),
+        "focus_areas": focus_areas or [],
+        "model": model or "default"
+    }) as span:
+        try:
+            agent = code_review_agent if model is None else Agent(
+                model=model,
+                result_model=CodeReviewResponse,
+                system_prompt=systemt_prompt, # Use the system prompt directly
+            )
+            prompt = (
+                f"Review the following code ({filename}).\n\n"  # noqa: E501
+                f"Focus areas: {', '.join(focus_areas or []) or 'general quality'}.\n\n"
+                f"{code}"
+            )
+            
+            # Log prompt generation
+            span.add_event("prompt_generated", attributes={
+                "prompt_length": len(prompt)
+            })
+            
+            run = await agent.run(prompt)
+            
+            # Log successful completion
+            span.add_event("review_completed", attributes={
+                "overall_score": run.data.overall_score,
+                "files_reviewed": len(run.data.files)
+            })
+            
+            return run.data
+            
+        except Exception as e:
+            # Log error
+            span.record_exception(e)
+            span.set_status(logfire.StatusCode.ERROR, str(e))
+            raise
 
 
 # =============================
@@ -415,28 +481,76 @@ def parse_args(argv: Optional[List[str]] = None) -> argparse.Namespace:
 
 
 def main(argv: Optional[List[str]] = None) -> int:
-    args = parse_args(argv)
-    if not args.paths:
-        print("No input paths provided. Nothing to review.")
-        return 2
-
-    result = asyncio.run(review_paths(args.paths, focus_areas=args.focus, model=args.model))
-
-    md = render_markdown(result)
-    if args.out:
-        Path(args.out).write_text(md, encoding="utf-8")
-        print(f"Saved review report to {args.out}")
-    else:
-        print(md)
-    return 0
+    # Start tracing span for CLI execution
+    with logfire_client.span("cli_execution", attributes={
+        "argv": argv or []
+    }) as span:
+        try:
+            args = parse_args(argv)
+            if not args.paths:
+                span.add_event("no_paths_provided")
+                print("No input paths provided. Nothing to review.")
+                return 2
+
+            # Log CLI arguments
+            span.add_event("cli_args_parsed", attributes={
+                "paths_count": len(args.paths),
+                "focus_areas": args.focus,
+                "model": args.model,
+                "output_file": args.out
+            })
+
+            result = asyncio.run(review_paths(args.paths, focus_areas=args.focus, model=args.model))
+
+            md = render_markdown(result)
+            if args.out:
+                Path(args.out).write_text(md, encoding="utf-8")
+                span.add_event("report_saved", attributes={"output_file": args.out})
+                print(f"Saved review report to {args.out}")
+            else:
+                span.add_event("report_printed_to_console")
+                print(md)
+            
+            span.add_event("cli_completed_successfully")
+            return 0
+            
+        except Exception as e:
+            # Log error
+            span.record_exception(e)
+            span.set_status(logfire.StatusCode.ERROR, str(e))
+            raise
 
 
 if __name__ == "__main__":
-    # raise SystemExit(main())
-    path = "DIFF.md"
-    data = read_text_file(path)
-    res = code_review_agent.run_sync("", deps = data)
-
-    print(res.output)
+    # Start tracing span for test execution
+    # with logfire_client.span("test_execution", attributes={
+    #     "test_type": "diff_review"
+    # }) as span:
+    #     try:
+    #         path = "DIFF.md"
+    #         span.add_event("reading_diff_file", attributes={"file_path": path})
+            
+    #         data = read_text_file(path)
+    #         span.add_event("diff_file_read", attributes={"content_length": len(data)})
+            
+    #         span.add_event("starting_agent_run")
+    #         res = code_review_agent.run_sync("", deps=data)
+            
+    #         span.add_event("agent_run_completed", attributes={
+    #             "output_length": len(res.output) if res.output else 0
+    #         })
+            
+    #         print(res.output)
+    #         span.add_event("test_completed_successfully")
+            
+    #     except Exception as e:
+    #         # Log error
+    #         span.record_exception(e)
+    #         span.set_status(logfire.StatusCode.ERROR, str(e))
+    #         raise
+
+    diff = read_text_file("DIFF.md")
+    data = code_review_agent.run_sync("", deps = DiffDeps(diff = diff))
+    print(data)
 
 

requirements.txt

@@ -1,4 +1,5 @@
 python-dotenv
 requests
 pydantic-ai
-flask
+flask
+logfire

test_logfire.py

@@ -0,0 +1,78 @@
+#!/usr/bin/env python3
+"""
+Test script to verify Logfire tracing is working correctly
+"""
+
+import os
+import asyncio
+from dotenv import load_dotenv
+import logfire
+# from agent.code_review import logfire_client
+
+load_dotenv()
+
+# async def test_logfire_tracing():
+#     """Test basic Logfire functionality"""
+    
+#     # Test basic span creation
+#     with logfire_client.span("test_span", attributes={"test": "basic_functionality"}) as span:
+#         span.add_event("test_event", attributes={"message": "Hello from Logfire!"})
+#         print("✓ Basic span creation and event logging works")
+    
+#     # Test error handling
+#     try:
+#         with logfire_client.span("error_test_span") as span:
+#             raise ValueError("Test error for tracing")
+#     except ValueError:
+#         print("✓ Error tracing works correctly")
+    
+#     # Test nested spans
+#     with logfire_client.span("parent_span") as parent_span:
+#         parent_span.add_event("parent_event")
+        
+#         with logfire_client.span("child_span") as child_span:
+#             child_span.add_event("child_event")
+#             print("✓ Nested spans work correctly")
+    
+#     print("✓ All Logfire tests passed!")
+
+# def test_sync_tracing():
+#     """Test synchronous tracing"""
+#     with logfire_client.span("sync_test") as span:
+#         span.add_event("sync_event", attributes={"type": "synchronous"})
+#         print("✓ Synchronous tracing works")
+    
+#     # Test exception handling
+#     try:
+#         with logfire_client.span("sync_error_test") as span:
+#             raise RuntimeError("Sync test error")
+#     except RuntimeError:
+#         print("✓ Synchronous error tracing works")
+
+# if __name__ == "__main__":
+#     print("Testing Logfire tracing functionality...")
+#     print(f"Logfire API Key configured: {'Yes' if os.getenv('LOGFIRE_API_KEY') else 'No'}")
+#     print()
+    
+#     # Test sync tracing
+#     test_sync_tracing()
+    
+#     # Test async tracing
+#     asyncio.run(test_logfire_tracing())
+    
+#     print("\n🎉 Logfire tracing is working correctly!")
+
+from pathlib import Path
+logfire.configure(token = os.getenv('LOGFIRE_API_KEY'))
+
+cwd = Path.cwd()
+total_size = 0
+
+with logfire.span('counting size of {cwd=}', cwd=cwd):
+    for path in cwd.iterdir():
+        if path.is_file():
+            with logfire.span('reading {path}', path=path.relative_to(cwd)):
+                total_size += len(path.read_bytes())
+
+    logfire.info('total size of {cwd} is {size} bytes', cwd=cwd, size=total_size)
+

tool.py

@@ -128,7 +128,7 @@ def send_slack_message(
 
     # Ưu tiên gửi qua Incoming Webhook nếu có
     if resolved_webhook_url:
-        payload: Dict[str, Any] = {"text": message_text}
+        payload: Dict[str, Any] = {"text": message_text, "type": "mrkdwn"}
         if blocks is not None:
             payload["blocks"] = blocks