Apply Changes and Create PR

Oct 13, 2025 by pinkandtrash.com 98 views

Roadmap Issue

Step 1: Set Up the GitHub Action Workflow

Create a file named .github/workflows/cline-agent.yml in your repository with the following content:

name: Cline Agent

on:
  issue_comment:
    types: [created]

jobs:
  handle_comment:
    runs-on: ubuntu-latest
    if: contains(github.event.comment.body, '@cline_agent')
    steps:
      - name: Checkout repository
        uses: actions/checkout@v4
        with:
          fetch-depth: 0

      - name: Get issue details
        id: issue
        uses: actions/github-script@v6
        with:
          script: |
            const issue = await github.rest.issues.get({
              owner: context.repo.owner,
              repo: context.repo.repo,
              issue_number: context.issue.number
            });
            core.setOutput('title', issue.data.title);
            core.setOutput('body', issue.data.body);

      - name: Send to AI agent
        id: ai_response
        env:
          AI_AGENT_API: ${{ secrets.AI_AGENT_API }}
        run: |
          curl -X POST "$AI_AGENT_API" \
            -H "Content-Type: application/json" \
            -H "Authorization: Bearer ${{ secrets.AI_AGENT_TOKEN }}" \
            -d '{
              "repository": "${{ github.repository }}",
              "issue_number": ${{ github.event.issue.number }},
              "issue_title": "${{ steps.issue.outputs.title }}",
              "issue_body": "${{ steps.issue.outputs.body }}",
              "comment": "${{ github.event.comment.body }}",
              "github_token": "${{ secrets.GITHUB_TOKEN }}"
            }' > ai_response.json

      - name: Parse AI response
        id: parse
        run: |
          changes=$(jq -r '.changes' ai_response.json)
          comment=$(jq -r '.comment' ai_response.json)
          echo "changes=$changes" >> $GITHUB_OUTPUT
          echo "comment=$comment" >> $GITHUB_OUTPUT

      - name: Apply changes and create PR
        id: pr
        run: |
          # Apply changes (assuming 'changes' is a patch file)
          echo "${{ steps.parse.outputs.changes }}" | git apply
          git checkout -b fix-issue-${{ github.event.issue.number }}
          git add .
          git commit -m "Fix issue #${{ github.event.issue.number }}"
          git push origin fix-issue-${{ github.event.issue.number }}
          pr_url=$(gh pr create --title "Fix issue #${{ github.event.issue.number }}" --body "Automated fix by Cline Agent")
          echo "pr_url=$pr_url" >> $GITHUB_OUTPUT
        env:
          GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}

      - name: Comment on issue
        uses: actions/github-script@v6
        with:
          script: |
            const comment = `${{ steps.parse.outputs.comment }}\n\nPull Request: ${{ steps.pr.outputs.pr_url }}`;
            await github.rest.issues.createComment({
              owner: context.repo.owner,
              repo: context.repo.repo,
              issue_number: context.issue.number,
              body: comment
            });

Explanation:

Trigger: The workflow runs when a new comment is created on an issue and checks if it contains '@cline_agent' using the if condition.
Checkout Repository: Clones the repository with full history (fetch-depth: 0) to allow applying changes.
Get Issue Details: Uses GitHub's REST API to fetch the issue's title and body via actions/github-script.
Send to AI agent: Makes a POST request to your AI agent's API endpoint with the issue details and a GitHub token for repository access.
Parse AI Response: Extracts the code changes (assumed to be a patch file) and solution comment from the AI's JSON response using jq.
Apply Changes and Create PR: Applies the changes, creates a new branch (e.g., fix-issue-42), commits, pushes, and opens a PR using the gh CLI.
Comment on Issue: Posts a comment on the issue with the solution description and PR link.

Prerequisites:

Install jq implicitly via the Ubuntu runner.
Ensure the gh CLI is available (pre-installed on GitHub-hosted runners).

Step 2: Configure Repository Secrets

In your GitHub repository, go to Settings > Secrets and variables > Actions > Secrets and add:

AI_AGENT_API: The URL of your AI agent’s API endpoint (e.g., https://your-agent-api.com/process).
AI_AGENT_TOKEN: An authentication token for your AI agent API (generate this when setting up the service).
GITHUB_TOKEN: Automatically provided by GitHub Actions with repository scope; no need to add manually, but it’s used in the workflow.

Step 3: Modify Cline's Backend for API Integration

Cline currently operates within an IDE, interacting with files and executing commands locally. To adapt it for a GitHub Action:

Create an API Endpoint: Add a server-side endpoint (e.g., /process-issue) to receive issue details.
Fetch Repository Files: Use the GitHub API to read files if needed, leveraging the provided github_token.
Generate a Solution: Adapt Cline’s logic to analyze the issue and produce code changes without IDE access.
Return a Response: Format the response as JSON with changes (e.g., a patch file) and a comment.

Example Backend Modification (Python with Flask):

Assuming Cline’s backend is Python-based (modify accordingly if it’s in another language):

from flask import Flask, request, jsonify
import anthropic  # Or your preferred API provider
from github import Github  # PyGitHub library
import difflib

app = Flask(__name__)

# Initialize your AI model client (e.g., Anthropic's Claude)
client = anthropic.Anthropic(api_key="your-anthropic-api-key")

@app.route('/process-issue', methods=['POST'])
def process_issue():
    data = request.get_json()
    repo_name = data['repository']
    issue_number = data['issue_number']
    issue_title = data['issue_title']
    issue_body = data['issue_body']
    comment = data['comment']
    github_token = data['github_token']

    # Access the repository using GitHub API
    g = Github(github_token)
    repo = g.get_repo(repo_name)
    
    # Example: Fetch a specific file (modify based on issue context)
    file_path = "main.js"  # Determine dynamically based on issue
    file = repo.get_contents(file_path)
    original_content = file.decoded_content.decode('utf-8')

    # Construct prompt for the AI model
    prompt = f"""
    Issue #{issue_number}: {issue_title}
    Description: {issue_body}
    Comment: {comment}
    File content:
    ```{file_path}
    {original_content}
    ```
    Please provide a solution by modifying the code and explain your changes.
    """
    
    # Call the AI model
    response = client.messages.create(
        model="claude-3-5-sonnet-20241022",
        max_tokens=1000,
        messages=[{"role": "user", "content": prompt}]
    )
    
    # Extract solution from AI response (assume it returns code and explanation)
    ai_response = response.content[0].text
    # Parse this based on how you instruct the AI to format its output
    new_content = ai_response.split("```")[1].strip()  # Example parsing
    explanation = ai_response.split("```")[2].strip()

    # Generate a patch file
    diff = ''.join(difflib.unified_diff(
        original_content.splitlines(keepends=True),
        new_content.splitlines(keepends=True),
        fromfile=f"a/{file_path}",
        tofile=f"b/{file_path}"
    ))

    # Return response
    return jsonify({
        "changes": diff,
        "comment": f"Proposed solution: {explanation}"
    })

if __name__ == "__main__":
    app.run(host="0.0.0.0", port=5000)

Notes:

Dependencies: Install flask, anthropic, and PyGitHub (pip install flask anthropic PyGitHub).
Prompt Engineering: Customize the prompt to ensure the AI returns code and an explanation in a consistent format (e.g., wrapped in code blocks).
File Access: Dynamically determine which files to fetch based on the issue or comment (e.g., parse the comment for file references).
Authentication: Use the github_token to authenticate API requests.

Step 4: Deploy the AI Agent Service

Deploy the modified backend to a serverless platform or traditional server:

AWS Lambda: Use a framework like serverless to deploy the Flask app.
Google Cloud Functions: Adapt the code to fit their function signature.
Traditional Server: Host on a VPS with a service like Gunicorn (gunicorn -w 4 app:app).

Example Deployment (AWS Lambda with Serverless Framework):

Install Serverless: npm install -g serverless
Create serverless.yml:

service: cline-agent

provider:
  name: aws
  runtime: python3.9

functions:
  processIssue:
    handler: app.process_issue
    events:
      - http:
          path: process-issue
          method:<br/>
**Q&A: Creating a GitHub Action with Cline's Autonomous Coding Capabilities**

**Q: What is Cline and how does it work?**

A: Cline is an autonomous coding tool that uses AI to generate code solutions for software development tasks. It operates within an Integrated Development Environment (IDE) and interacts with files and executes commands locally. To adapt Cline for a GitHub Action, we need to modify its backend to work within a serverless setup that can be triggered by GitHub events.

**Q: What is a GitHub Action and how does it work?**

A: A GitHub Action is a workflow that automates tasks on GitHub, such as building, testing, and deploying code. It consists of a YAML file that defines the workflow, which is triggered by events such as push, pull request, or issue comment. The workflow can perform various tasks, including running scripts, making API calls, and interacting with other services.

**Q: How do I set up a GitHub Action with Cline's autonomous coding capabilities?**

A: To set up a GitHub Action with Cline's autonomous coding capabilities, you need to:

1. Create a new file in your repository's `.github/workflows` directory with a YAML file that defines the workflow.
2. Configure the workflow to listen for issue comments containing `@cline_agent`.
3. Modify Cline's backend to work within a serverless setup that can be triggered by GitHub events.
4. Deploy the modified backend to a serverless platform or traditional server.
5. Configure repository secrets to store the AI agent's API endpoint and authentication token.

**Q: What are the benefits of using a GitHub Action with Cline's autonomous coding capabilities?**

A: The benefits of using a GitHub Action with Cline's autonomous coding capabilities include:

* **Automated code generation**: Cline's AI can generate code solutions for software development tasks, reducing the time and effort required for coding.
* **Improved collaboration**: The GitHub Action can be triggered by issue comments, allowing developers to collaborate more effectively and efficiently.
* **Enhanced productivity**: The automated code generation and collaboration features can help developers work more productively and focus on higher-level tasks.

**Q: How do I troubleshoot issues with the GitHub Action?**

A: To troubleshoot issues with the GitHub Action, you can:

* **Check the workflow logs**: Review the workflow logs to identify any errors or issues.
* **Verify the AI agent's API endpoint**: Ensure that the AI agent's API endpoint is correctly configured and accessible.
* **Test the workflow**: Test the workflow manually to ensure that it is working as expected.

**Q: Can I customize the GitHub Action to fit my specific needs?**

A: Yes, you can customize the GitHub Action to fit your specific needs. You can modify the workflow to perform additional tasks, such as running scripts or making API calls, and you can also customize the AI agent's backend to work with your specific use case.

**Q: How do I deploy the GitHub Action to a production environment?**

A: To deploy the GitHub Action to a production environment, you need to:

* **Configure the workflow to run in a production environment**: Update the workflow to run in a production environment, such as a serverless platform or a traditional server.
* **Verify the workflow's performance**: Test the workflow's performance in a production environment to ensure that it is working as expected.
* **Monitor the workflow's logs**: Monitor the workflow's logs to identify any issues or errors.

By following these steps and troubleshooting tips, you can create a GitHub Action with Cline's autonomous coding capabilities that meets your specific needs and enhances your development workflow.