Setting up a new Github Action Application for AI Support

.github/workflows/action.yml

@@ -10,13 +10,18 @@ jobs:
         steps:
           - name: Checkout code
             uses: actions/checkout@v2
-          - name: Set up Node
-            uses: actions/setup-node@v2
+          - uses: actions/setup-node@v4
+            with:
+              node-version: 18
+          - name: Install dependencies
+            run: npm install
+          - name: Build Code
+            run: npm run build
           - name: Run Custom Action
             uses: ./
             with:
-              github-token: ${{ secrets.GITHUB_TOKEN }}
-              pr-number: ${{ github.event.number }}
-              openai_api_key: ${{ secrets.OPENAI_API_KEY }}
-              openai_model: 'gpt-4'
+              github_token: ${{ secrets.GITHUB_TOKEN }}
+              openai_api_key: ${{ secrets.OPEN_AI_KEY }}
+              openai_model: "gpt-4o"
               review_code: true
+              expluded_files: "node_modules, package.json, package-lock.json"

action.yml

@@ -2,12 +2,13 @@ name: 'Github PR Magic'
 description: 'Automatically reviewing and approving PRs'
 author: 'Darrell Richards'
 inputs:
-  github-token:
+  github_token:
     description: 'Github token'
     required: true
-  pr-number:
-    description: 'PR number'
-    required: true
+  excluded_files:
+    description: 'Files to exclude from review'
+    required: false
+    default: "node_modules, package-lock.json, yarn.lock"
   openai_api_key:
     description: 'OpenAI API key'
     required: true
@@ -19,6 +20,14 @@ inputs:
     description: 'Review code'
     required: false
     default: true
+  generate_summary:
+    description: 'Generates Pull Request summary based on git diff and code changes'
+    required: false
+    default: false
+  overall_code_review:
+    description: 'Overall code review as a comment'
+    required: false
+    default: false
 runs:
   using: 'node20'
   main: 'lib/index.js'

package.json

@@ -12,8 +12,9 @@
   "dependencies": {
     "@actions/core": "^1.10.1",
     "@octokit/rest": "^20.1.1",
-    "@tandil/diffparse": "^0.2.0",
+    "@octokit/types": "^13.5.0",
     "minimatch": "^9.0.4",
-    "openai": "^4.47.3"
+    "openai": "^4.47.3",
+    "parse-diff": "^0.11.1"
   }
 }

src/index.ts

@@ -1,40 +1,210 @@
-const parser = require('@tandil/diffparse');
 import { readFileSync } from "fs"
-import OpenAI from "openai"
-import core from "@actions/core";
-import { PRDetails } from "./lib/github";
+import parseDiff, { File } from "parse-diff"
+import * as core from "@actions/core"
+
+import { commentOnPullRequest, compareCommits, createReviewComment, getPullRequestDiff, PRDetails, updateBody } from "./services/github";
 import { minimatch } from "minimatch";
+import { obtainFeedback, prSummaryCreation, summaryAllMessages, summaryOfAllFeedback, validateCodeViaAI } from "./services/ai";
+
+
+const excludedFiles = core.getInput("excluded_files").split(",").map((s: string) => s.trim());
+const createPullRequestSummary = core.getInput("generate_summary");
+const reviewCode = core.getInput("review_code")
+const overallReview = core.getInput("overall_code_review");
+
+
+export interface Details {
+    title: string;
+    description: string;
+}
+
+async function validatePullRequest(diff: File[], details: Details) {
+    const foundSummary = [];
+    for (const file of diff) {
+        for (const chunk of file.chunks) {
+            const message = await prSummaryCreation(file, chunk, details);
+            if (message) {
+                const mappedResults = message.flatMap((result: any) => {
+                    if (!result.changes) {
+                        return [];
+                    }
+
+                    if (!result.typeChanges) { 
+                        return [];
+                    }
+
+                    if (!result.checklist) {
+                        return [];
+                    }
+
+
+                    return {
+                        changes: result.changes,
+                        typeChanges: result.typeChanges,
+                        checklist: result.checklist,
+                    };
+                });
+
+                foundSummary.push(...mappedResults);
+            }
+        }
+    }
+
+
+    if (foundSummary && foundSummary.length > 0) {
+        const compiledSummary = await summaryAllMessages(foundSummary);
+        return compiledSummary;
+    }
+
+    return '';
+}
+
+async function validateCode(diff: File[], details: Details) {
+    const neededComments = [];
+    for (const file of diff) {
+        for (const chunk of file.chunks) {
+            const results = await validateCodeViaAI(file, chunk, details);
+
+            if (results) {
+                const mappedResults = results.flatMap((result: any) => {
+                    if (!file.to) {
+                        return [];
+                    }
+
+                    if (!result.lineNumber) {
+                        return [];
+                    }
+
+                    if (!result.review) { 
+                        return [];
+                    }
+
+                    return {
+                        body: result.review,
+                        path: file.to,
+                        line: parseInt(result.lineNumber, 10)
+                    };
+                });
+
+                if (mappedResults) {
+                    neededComments.push(...mappedResults);
+                }
+            }
+        }
+    }
+
+    return neededComments;
+}
+
+async function validateOverallCodeReview(diff: File[], details: Details) {
+    const detailedFeedback = [];
+    for (const file of diff) {
+        for (const chunk of file.chunks) {
+            const results = await obtainFeedback(file, chunk, details);
+            if (results) {
+                const mappedResults = results.flatMap((result: any) => {
+                    if (!file.to) {
+                        return [];
+                    }
+
+                    return {
+                        changesOverview: result.changesOverview,
+                        feedback: result.feedback,
+                        improvements: result.improvements,
+                        conclusion: result.conclusion,
+                    };
+                });
+
+                if (mappedResults) {
+                    detailedFeedback.push(...mappedResults);
+                }
+            }
+        }
+    }
+
+    return detailedFeedback;
+}
 
-const openai = new OpenAI()
-const excludedFiles = core.getInput("exclude").split(",").map((s: string) => s.trim());
 
 async function main() {
     let dif: string | null = null;
-    const { action, repository, number } = JSON.parse(readFileSync(process.env.GITHUB_EVENT_PATH || "", "utf-8"))
+    const { action, repository, number, before, after } = JSON.parse(readFileSync(process.env.GITHUB_EVENT_PATH || "", "utf-8"))
     const { title, description } = await PRDetails(repository, number);
-
-    if (action === "opened") {
-        // Generate a summary of the PR since it's a new PR
-
+    if (action === "opened" || action === "reopened") {
+        const data = await getPullRequestDiff(repository.owner.login, repository.name, number);
+        dif = data as unknown as string;
+    } else if (action === "synchronize") {
+        const newBaseSha = before;
+        const newHeadSha = after;
+
+        const data = await compareCommits({
+            owner: repository.owner.login,
+            repo: repository.name,
+            before: newBaseSha,
+            after: newHeadSha,
+            number
+        })
+
+        dif = String(data);
+    } else {
+        console.log('Unknown action', process.env.GITHUB_EVENT_NAME);
+        return;
     }
 
     if (!dif) {
-        // Well shit.
+        console.log('No diff found, exiting')
         return;
     }
 
-    const diff = parser.parseDiffString(dif);
-    const filteredDiff = diff.filter((file: { to: any; }) => {
+    const diff = parseDiff(dif);
+    const filteredDiff = diff.filter((file) => {
         return !excludedFiles.some((pattern) =>
           minimatch(file.to ?? "", pattern)
         );
     });
 
-    console.log(filteredDiff);
+    if (action === "opened") {
+        if (createPullRequestSummary) {
+            console.log('Generating summary for new PR');
+            const summary = await validatePullRequest(diff, {
+                title,
+                description
+            });
+
+            if (summary) {
+                await updateBody(repository.owner.login, repository.name, number, summary);
+            }
+        }
 
-    // Validate Some Code Yo!
+        if (overallReview) {
+            const detailedFeedback = await validateOverallCodeReview(filteredDiff, {
+                title,
+                description
+            });
+
+            if (detailedFeedback && detailedFeedback.length > 0) {
+                const resultsFullFeedback = await summaryOfAllFeedback(detailedFeedback);
+                if (resultsFullFeedback) {
+                    await commentOnPullRequest({
+                        owner: repository.owner.login,
+                        repo: repository.name,
+                        number
+                    }, resultsFullFeedback);
+                }
+            }
+        }
+    }
 
-    // Post some comments
+    if (reviewCode) {
+        const neededComments = await validateCode(filteredDiff, {
+            title,
+            description
+        });
+
+        if (neededComments) {
+            await createReviewComment(repository.owner.login, repository.name, number, neededComments);
+        }
+    }
 }
 
-main();
+main();