סקירת קוד, תיקון אוטומטי וממשל Pull Requests עם AI

שלוט בכלים המודרניים לאוטומציה של סקירת קוד וניהול PR בעזרת בינה מלאכותית

רמת קורס

כל הרמות

משך הקורס

16 שעות

יעדי הקורס

הבנת עקרונות סקירת קוד מודרנית והשימוש ב-AI
יכולת להגדיר ולהריץ כלי תיקון אוטומטי כמו Copilot, CodeRabbit ו-Sonar
ניהול יעיל של Pull Requests עם Bots וAutomation
יישום Best Practices לממשל קוד ואוטומציה של QA

יסודות סקירת קוד בעידן ה-AI

סקירת קוד היא אחד התהליכים החשובים ביותר בפיתוח תוכנה מודרני. היא משמשת לא רק לתפיסת באגים, אלא גם לשיתוף ידע, שמירה על קוד אחיד וטיפול בסיכוני אבטחה. בעידן ה-AI, סקירת קוד עברה מהפכה בה כלים חכמים יכולים לבצע ניתוחים מתקדמים ותיקונים אוטומטיים תוך שניות, בעוד הבדיקה האנושית מתמקדת בהיבטים לוגיים ועסקיים.

אתגרים בסקירה ידנית מסורתית כוללים בעיות כמו זמן בדיקה ארוך, חוסר עקביות בקריטריונים, אובדן מוקד בדיקות שוטפות וכשל בתפיסת באגים עדינים. כאשר צוות פיתוח גדל, הבעיות האלו רק מתגברות. כלים המונעים על ידי AI מסוגלים לנתח קוד בשנייה וליישם עקביות מלאה, מה שמשחרר מתכנתים למשימות בעלות ערך גבוה יותר.

הכלים המובילים בשוק כיום כוללים GitHub Copilot, המשלב ביצירה וסקירה; CodeRabbit, המתמחה בניתוח PR; SonarQube, המוקדש לניתוח איכות קוד מתקדם; ו-GitLab Merge Request האינטגרציה המקומית. כל כלי יש חוזקות ייחודיות, וההטמעה המוצלחת דורשת הבנה עמוקה של יכולותיהם וכיצד הם משתלבים בזרימת עבודה של הצוות.

מהי סקירת קוד וחשיבותה בפיתוח מודרני

סקירת קוד היא תהליך שבו מתכנתים בודקים קוד שנכתב על ידי עמיתים לפני שהוא מוחלק לענף הראשי. הסקירה בודקת נכונות, ביצועים, בטיחות, וקביעות קוד. בחברות מהן כמו Google ו-Facebook, כל קו קוד עובר סקירת קוד קפדנית לפני הוספה, וזה תורם בצורה ישירה לאיכות הקוד והעמידות של המערכות שלהן.

אתגרים בסקירת קוד ידנית

סקירה ידנית גוררת מספר בעיות: (1) היא זמנית ולעתים קרובות כבלתי מדדת, (2) היא תלויה בנוכחות ובזמן של reviewers, (3) היא מוצאת בעיות רק אם ה-reviewer היה בנימוס (4) הצטברות של PR ממתינות יוצרת עיכובים בדפיסה. תיוג סטנדרטי וקריטריונים ברורים יכולים להשתפר, אך דורשים משאבים משמעותיים וסדרי עדיפויות.

כיצד AI משנה את תהליך הסקירה

AI מביא שלושה שינויים עיקריים: (1) מהירות — בדיקה מיידית של קוד מול קריטריונים מוגדרים, (2) כיסוי — זיהוי בעיות שאנוש עלול להחמיץ כמו חולשות אבטחה או דפוסים בעלי ביצועים נמוכים, (3) עקביות — כלים תמיד יישמו חוקים באותו אופן. זה מאפשר ל-reviewers אנוש להתמקד בהיבטים אסטרטגיים ובעיות לוגיות שלעתים קרובות יש חשיבות גבוהה יותר.

// דוגמה: בדיקה אוטומטית עם AI
function calculateTotal(items) {
  let total = 0;
  for (let i = 0; i < items.length; i++) {
    total += items[i].price * items[i].quantity;
  }
  return total;
}

// בדיקות שכלים כמו AI יוכלו לבטל:
// ✓ בדוק ריקום (items הוא null?)
// ✓ בדוק אם price או quantity הם מספרים
// ✓ בדוק הצפנה על סכומים גדולים (overflow)
// ✓ בדוק וריאציות נוכחיות (const vs let)
      

טיפ: התחל קטן

אל תנסה להטמיע את כל הכלים בבת אחת. התחל עם כלי אחד (מומלץ GitHub Copilot או CodeRabbit) ושלוט בו לפני הוספת אחרים.

כלים ופלטפורמות AI מובילות

בשוק כיום קיימים כמה שחקנים מרכזיים: GitHub Copilot (Codex על ידי OpenAI), CodeRabbit (מתמחה בסקירת PR), SonarQube (סקן איכות מתקדם), GitLab AI Features, ו-Renovate (ניהול עדכוני תלויות). כל אחד יש מחיר שונה, יכולות שונות, וקימות שונות בשרשרת הערך של הסקירה.

בקורס זה נלמד להשתמש בשלושת הכלים העיקריים — Copilot, CodeRabbit ו-SonarQube — בשילוב עם GitHub Actions ו-GitLab CI/CD, יצירת מערכת ממשלית קוד מעצמית וחכמה.

GitHub Copilot וסקירה אוטומטית של קוד

GitHub Copilot הוא כלי משתמש שהונע על ידי Codex של OpenAI, ומשלב בין יצירת קוד בזמן אמת לבין סקירה חכמה. זה נמצא בתוך IDE כמו VS Code, JetBrains או Visual Studio, והוא משתמש בהקשר של הקוד הנוכחי כדי להציע השלמות ולהדגיש בעיות פוטנציאליות. בניגוד לכלים אחרים שמריצים כחלק של CI/CD, Copilot עובד בזמן עריכה, מה שמביא לפרודוקטיביות מיידית.

הנוכחות של Copilot ב-IDE פירושה שמתכנתים מקבלים משוב מיידי כשהם כותבים. הם רואים הצעות להשלמה, הערות על בעיות אפשריות (כמו משתנים לא מוגדרים או רגע לא בטוח), וההערוצים לשיפור קוד. זה משנה את זרימת העבודה: במקום חכות למשוב בסקירה ידנית, מתכנתים קוראים משוב מיידי ויכולים לתקן בעיות לפני שהם מגישים PR.

בשרשרת GitHub, Copilot משתלב גם עם PR Checks. ניתן להגדיר Workflows ש-invoke Copilot API כדי לבצע סקירה אוטומטית של PR וליצור תגובות. זה מוסיף שכבה נוספת של אוטומציה לאחר שהקוד כבר התקבל. בשילוב עם GitHub Checks, Copilot יכול לחסום PR אם הוא מוצא בעיות קריטיות או בטיחות.

הגדרת Copilot בסביבת הפיתוח

להתקנת Copilot: (1) התחברו לחשבון GitHub שלכם עם אישור GitHub Copilot, (2) התקינו את התוסף Copilot ל-IDE שלכם (VS Code: GitHub.Copilot extension), (3) בעת ההפעלה הראשונה, ה-IDE יבקש הרשאה לחיבור GitHub, (4) אמתו דרך ה-browser וחזרו ל-IDE. מכאן והלאה, Copilot פעיל בכל קובץ שתערוך.

להתאמה אישית, עברו ל-Settings/Preferences וחפשו "GitHub Copilot". כאן אתם יכולים לשנות התנהגויות כמו סמוטו לבדיקה (Autotab), כדי להתגובות (Show Completions), ותוכן סוג (Languages to filter). בקובץ .copilotignore (אם קיים בשורש הפרויקט), אתם יכולים לציין אילו קבצים Copilot לא צריך לנתח — שימושי עבור קבצים רגישים או מובילים לאבטחה.

// דוגמה: שימוש ב-Copilot להשלמה חכמה
// כשמקלידים את זה, Copilot יציע השלמות

// ניתן לנחש: מטרה היא לחשב את הגובה של עץ בינארי
function calculateTreeHeight(node) {
  // Copilot יציע:
  if (node === null) return 0;
  const leftHeight = calculateTreeHeight(node.left);
  const rightHeight = calculateTreeHeight(node.right);
  return 1 + Math.max(leftHeight, rightHeight);
}

// Copilot גם יקחיד:
// - משתנים שלא מוגדרים (node.left בלי בדיקה שהוא קיים בראשון)
// - דפוסים שיפורים (להשתמש במטמון במקום חישוב מחדש)
      

שימוש ב-Copilot למציאת באגים וחוסנים

Copilot לא רק משלים קוד — הוא גם מהווה משמר ודוגל בשיפורים. כשזה רואה דפוס שונה או בעיה לא בטוחה, זה יכול להדגיש אזהרות ב-IDE. לדוגמה, אם אתה כותב ביטוי שיכול להיות ריק (null/undefined), Copilot יציע בדיקה תנאית. אם אתה כותב קוד שקשור לאבטחה (כמו קידוד סיסמה), Copilot יזהיר מפני גישה חלשה וייצע דרך מאובטחת יותר.

Copilot יכול גם לקרוא קוד קיים ולהציע שיפורים בביצועים. לדוגמה, אם הוא רואה לולאה שמבצעת חיפוש לינארי, זה יכול להציע שימוש בווש או בסדרה מהירה יותר. זה לא תמיד יצודק (כי יכול להיות שה-data structure הוא קטן), אך זה מכניס דיון חשוב על בחירות.

בטיחות: בדוק הצעות של Copilot

Copilot הדרך על נתונים אימון (GitHub repos), שחלקם יכול להכיל קוד בעל פגמים או רגלי הנדסה חלשות. תמיד בדוק את ההצעות שלו, במיוחד לקוד ביטחוני.

Copilot Pull Request Reviews

כדי להשתמש ב-Copilot עבור סקירת PR, עברו ל-Repository Settings → Actions → Secrets, והוסיפו secret בשם GITHUB_TOKEN (GitHub generats this automatically). לאחר מכן, תוכלו ליצור GitHub Action Workflow שמריץ Copilot כחלק של PR Review.

name: Copilot PR Review
on:
  pull_request:
    types: [opened, synchronize]

jobs:
  review:
    runs-on: ubuntu-latest
    permissions:
      pull-requests: write
      contents: read
    steps:
      - name: Run Copilot Review
        uses: github/copilot-review-action@v1
        with:
          github-token: ${{ secrets.GITHUB_TOKEN }}
      

אינטגרציה עם GitHub Checks

GitHub Checks היא מערכת נתיבה ב-GitHub המאפשרת ל-CI/CD ו-bots לדווח על סטטוס בדיקות כולל משימות, הודעות מפורטות וקישורים לפרטים נוספים. כאשר Copilot רץ כחלק של PR, הוא פרסם תוצאה ב-Checks tab, שם ה-reviewer יכול לראות מיד אם יש בעיות ודברים מה-Copilot הציע.

דוגמה של תוצאה: "✓ Copilot Review Passed (0 issues found)" או "✗ Copilot Review Failed (3 critical issues)". ניתן גם להגדיר את ה-Workflow כך שתוצאת Copilot תחסום merge עד שהבעיות יטופלו, או ניתן להגדיר אותה להיות משום-informative ולא חסם.

CodeRabbit — סקירה חכמה של PR

CodeRabbit היא כלי מתמחה בסקירת Pull Requests, שפותח כחברה קטנה ואחרונה מוקרנת כמו כלי מקצועי בדירוג גבוה. בניגוד ל-Copilot שהוא פוק-כלי בתוך IDE, CodeRabbit נמצא בשרשרת GitHub כסט של automations הפועלים בכל PR חדש או עדכון. CodeRabbit מנתח את כל הדיפ (diff) של הקוד המשתנה, משווה לקוד ישן, ובודק דפוסים, טעויות נפוצות, סוגיות ביטחון וביצועים.

יתרון CodeRabbit על פני כלים אחרים הוא מיוחדותו לסקירת PR. בעוד Copilot משמש לעריכה ו-SonarQube משמש לסקן סטטי בעל מטרה כללית, CodeRabbit מתמקד בשינויים בדיוק. זה מבין התקשרות בדיפ וביכול לתיקן הערות מוטבעות בגיט, שנראות בדיוק במקום בו השינוי בוצע — משום כאומנה הבדיקה מרוכזת.

CodeRabbit זמין כ-GitHub App שתוכלו להתקין בחינם (עם מגבלות) או בתשלום לפי שימוש. יש גם גרסת Enterprise לחברות הדורשות דפיון מקומי או בקרה משפחתית. החברה מפרסמת גם דפי תעדוף ודוחות, כך שניתן לתעד את שיפור האיכות לאורך זמן.

מהו CodeRabbit ומתי להשתמש בו

CodeRabbit הוא בוט שמופעל על ידי LLM גדול (דומה ל-GPT-4) שמתוכנת ספציפית לסקירת קוד. המטרה שלו היא לאתור פגמים בהערה ולהיות עזר אמין ל-reviewer האנושי. CodeRabbit מתאים במיוחד כאשר: (1) לצוות שלכם יש צפי בדיקה גבוה, (2) חסרון של reviewers מעתוקים, (3) רציונל בחסך בקדקד, (4) ביחס לתקופה בה PR יושמות להתבדרות חדשות או תכונות מנויות שדורשות בדיקה נוקשה.

CodeRabbit הפחות טוב כאשר: (1) יש צוות קטן עם דינמיקה חזקה בנוגע לנוגעים בקוד, (2) הקוד כולל הרבה ביטויים ייחוס עטופים בהודעות דו-משמעיות, (3) יש צוביות בטיחות גבוהה שדורשת סקירה אנושית נוספת.

הגדרה והתאמה של CodeRabbit

להתקין CodeRabbit: (1) עברו ל-GitHub Marketplace וחפשו "CodeRabbit", (2) לחצו על "Install", בחרו את החשבון שלכם, ואמתו הגישה, (3) בחרו "Only select repositories" או "All repositories" לפי הצורך שלכם, (4) אשרו את ההתקנה.

להתאמה אישית, צרו קובץ .coderabbit.yaml בשורש הפרויקט. בקובץ זה, אתם יכולים לציין: (1) אילו שפות לנתח (languages), (2) איזה סוגי בעיות חשובות ביותר (priority), (3) כללים מותאמים (custom rules), (4) אילו מסלולים להתעלם (ignore_paths).

# .coderabbit.yaml — קובץ התאמה
language:
  - javascript
  - typescript
  - python

rules:
  - name: security
    enabled: true
    severity: critical
  - name: performance
    enabled: true
    severity: high
  - name: style
    enabled: false  # Don't check style issues

ignore_paths:
  - "dist/**"
  - "build/**"
  - "node_modules/**"
      

סקירה אוטומטית של שינויים

כאשר CodeRabbit מופעל, כל PR חדש או עדכון יגיד סקירה אוטומטית. CodeRabbit יצור תגובה בדיוקו של הדיפ, בדיוק כמו reviewer אנושי היה אומר "בשורה זו, יש בעיה...". התגובות מובנות וקצרות, עם הצעות לתיקון או דוגמות של קוד טוב יותר.

לדוגמה, אם CodeRabbit רואה משתנה בשם x כשניתן להשתמש בשם משמעותי יותר, זה יציע שיוב. אם זה רואה בדוק ריקום (null check) בחסר, זה יציע להוסיף אותה. אם זה רואה SQL query המודבקת (susceptible to injection), זה יציע parameterized query.

ניהול הערות והצעות תיקון

CodeRabbit מאפשר לך לשנות או לדחות הערות. בכל תגובה של CodeRabbit, יש אפשרות "View suggestion" ו-"Dismiss". אם הערה לא רלוונטית (לדוגמה, CodeRabbit מציע שיפור שלא מתאים להקשר), אתה יכול פשוט להדוחק אותה. CodeRabbit לומד מן ההערות, כך שפעם הבאה זה פחות סביר להציע אותו הדבר.

אם אתה מסכים עם הערה, CodeRabbit יכול להציע תיקון אוטומטי. בחרו "Commit suggestion" וגיט יתקבע ישירות ל-branch שלכם. זה נעשה בהתייצבות של commit נדרש כך שרלוונטיות משמורת בהסטוריה.

טיפ: צפו בדוחות

CodeRabbit מתעד דוחות בשבועות (hebdomadal reports) המראים כמה בעיות נמצאו, אילו סוגי בעיות הן נפוצות ביותר, ומי כותב קוד עם פחות בעיות. השתמשו בנתונים אלה לשיפור מתמיד.

דוחות ואנליטיקס

דשבורד CodeRabbit מציג נתונים כמו: מספר סה"כ של בעיות שנמצאו, התפלגות לפי סוג בעיה (security, performance, style), שיעור של בעיות שתוקנו לעומת דחויות, וטרנדים לאורך זמן. זה עוזר לצוות להבין האם איכות הקוד משתפרת או מהדרדרת.

דוחות אלו אפשר גם להוריד כ-CSV או JSON, מה שמאפשר אינטגרציה עם כלים אחרים של ניתוח או אחסון תיעוד.

SonarQube וניתוח איכות קוד מתקדם

SonarQube הוא כלי סקן קוד סטטי (SAST — Static Application Security Testing) שהתחיל בשנים 2000 וכיום הוא כלי האנטרפריז הנתמך ביותר עבור ניתוח איכות קוד. בניגוד ל-Copilot שעובד בזמן אמת וב-CodeRabbit שמתמקד בדיפים, SonarQube מסרק את כל הבסיס הקוד (codebase) או ענפים ספציפיים ויוצר דוח מפורט על איכות, אבטחה, ביצועים וקביעות.

SonarQube פועל בשלושה מצבים: (1) SonarQube Community (open-source, חינם), (2) SonarQube Developer Edition (בתשלום, יותר תכונות), (3) SonarQube Enterprise (בתשלום גבוה, מצרכים ארגוניים). הרוב של חברות בגודל בינוני ומעלה משתמש ב-SonarQube Enterprise בגלל היכולת שלו לנהל מאות פרויקטים, עם דפיון מקומי ובקרת תאריכים.

SonarQube משתלב בקלות עם CI/CD pipelines (GitHub Actions, Jenkins, GitLab CI וכו'), כך שכל build מפעילה סקן מלא. זה יכול גם לחסום דיפוזיה (block deployment) אם איכות הקוד נופלת מתחת לסף מוגדר (quality gate).

ניתוח איכות קוד עם SonarQube

להתקנת SonarQube בעצמכם: (1) הורידו את הגרסה המקומית מ-sonarqube.org, (2) התקינו Java Runtime Environment (JRE) כי SonarQube כתוב בג'אווה, (3) הפעילו את SonarQube locally (./bin/[OS]/sonar.sh start), (4) פתחו את http://localhost:9000 ב-browser (username: admin, password: admin), (5) צרו project חדש וקבלו token לשימוש בקוד שלכם.

לחלופה, אתם יכולים להשתמש ב-SonarQube Cloud (sonarcloud.io), שהוא גרסת SaaS מנוהלת של סונר שלא דורשת התקנה עצמית. החברה מה-SonarQube (Sonar) מנהלת את השרתים, ואתם פשוט משחקים את ה-token שלכם לגיט.

# צעד 1: התקנת SonarQube Scanner (CLI)
npm install -g sonarqube-scanner

# צעד 2: הפעלת סקן
sonar-scanner \
  -Dsonar.projectKey=my-app \
  -Dsonar.sources=src \
  -Dsonar.host.url=http://localhost:9000 \
  -Dsonar.login=[YOUR_TOKEN]

# צעד 3: התוצאות מופיעות ב-http://localhost:9000
      

זיהוי ודיווח על בעיות בטיחות

SonarQube יכול לזהות מאות סוגי בעיות בטיחות: SQL injection, XSS (Cross-Site Scripting), hardcoded passwords, weak cryptography, insecure deserialization וכו'. כל בעיה מדורגת לפי חומרה (Critical, High, Medium, Low) ונותן הסבר מפורט ודוגמה של קוד בטוח.

לדוגמה, אם SonarQube רואה קוד כמו `password = "mypassword123"` (hardcoded password), זה יצור דיווח בעלת מידת ביטחון "Critical". הדיווח יצרף הסבר (למה זה מסוכן) ודוגמה של קוד בטוח (שימוש במשתני סביבה או secret manager).

טכניקות תיקון אוטומטי של SonarQube

SonarQube עצמו לא מעדכן קוד אוטומטית, אך מספר סקנרים (כמו ESLint עם עוקבי SonarQube) יכול לאפשר "autofixes". לדוגמה, אם SonarQube מזהה משתנה לא מוגדר, ESLint או Prettier יכול לתקן אותו אוטומטית. אתה גם יכול לכתוב scripts קטנים שקוראים ממוצא SonarQube ומחילים תיקונים נפוצים.

טיפ: שילוב עם CI/CD

SonarQube עובד הטוב ביותר כשהוא רץ בכל build. הוסיפו סקן SonarQube ל-GitHub Actions או Jenkins pipeline שלכם כדי לתפוס בעיות מיד.

אינטגרציה עם CI/CD Pipeline

להוסיף SonarQube ל-GitHub Actions, צרו קובץ workflow בשם .github/workflows/sonarqube.yml:

name: SonarQube Scan
on:
  push:
    branches: [ main ]
  pull_request:
    branches: [ main ]

jobs:
  sonarqube:
    runs-on: ubuntu-latest
    steps:
      - uses: actions/checkout@v3
      - name: SonarQube Scan
        uses: SonarSource/sonarqube-scan-action@master
        env:
          SONAR_HOST_URL: ${{ secrets.SONAR_HOST_URL }}
          SONAR_TOKEN: ${{ secrets.SONAR_TOKEN }}
      

דוחות ודשבורדים

דשבורד SonarQube מציג: Coverage (כמה קוד מכוסה על ידי בדיקות), Duplications (קוד משוכפל), Bugs (באגים), Vulnerabilities (חולשות), Code Smells (דפוסים שאינם אופטימליים). כל עמוד מקשקש קישורים להצגת פרטים — לחצו על "Bugs" וראו רשימה של כל הבאגים המצוים בפרויקט.

SonarQube גם יכול לשלוח דוחות דוא"ל שבועיים או חודשיים, וגם לשלוח Webhooks לשירותים אחרים (כמו Slack) כל פעם שתוצאה משתנה. זה עוזר לצוות להישאר מעודכן באיכות הקוד.

GitHub Actions ובוטים לממשל PR

GitHub Actions היא פלטפורמת אוטומציה בנויה ישירות ב-GitHub, המאפשרת לך לכתוב Workflows המריצים קוד בתגובה ללאומים גיט (push, pull_request, release וכו'). Workflows כתובים ב-YAML ומורכבים מחזרות (jobs) ותצעדים (steps). כל תצעד יכול להריץ shell commands, להשתמש ב-Actions חיצוניות (מהשוק), או להריץ קוד Python/JavaScript מובנה.

GitHub Actions משלב על פי הכנה עם סקירת קוד אוטומטית, ניהול PR אוטומטי, וממשל איכות. אתה יכול ליצור Workflows שמריצים בדיקות יחידה, סקנים בטיחות, בדיקות עיניות (visual regression), וכל דבר אחר. אם בדיקה נכשלת, GitHub יכול לחסום PR מ-merge, או להשתלח הודעות לצוות.

עבור Bots, GitHub Actions גם יכול ליצור Bots שמניהלים PRs. לדוגמה, אתה יכול ליצור Bot שמאשר PR אוטומטית אם כל הבדיקות עברו, או Bot שמעדכן dependencies בעת שחרור גרסה חדשה. GitHub הוא יותר רחב ממנה כדי שהבוט להיות גם ירשום באזרחו, יטפל בהערות reviewers, וגם יארגן תגובות.

כתיבת Workflows עבור סקירת קוד אוטומטית

צרו קובץ .github/workflows/code-review.yml:

name: Automated Code Review
on:
  pull_request:
    types: [opened, synchronize]

jobs:
  lint:
    runs-on: ubuntu-latest
    steps:
      - uses: actions/checkout@v3
      
      - name: Set up Node.js
        uses: actions/setup-node@v3
        with:
          node-version: '18'
      
      - name: Install dependencies
        run: npm install
      
      - name: Run ESLint
        run: npm run lint
      
      - name: Run tests
        run: npm test
      
      - name: Check coverage
        run: npm run coverage

  security:
    runs-on: ubuntu-latest
    steps:
      - uses: actions/checkout@v3
      - name: Run Snyk
        uses: snyk/actions/node@master
        env:
          SNYK_TOKEN: ${{ secrets.SNYK_TOKEN }}
      

Workflow זה רץ כל פעם שנפתח PR חדש או כשדוחפים commits לקיים PR. זה מסובב ESLint וטעסטים, וגם בודק בטיחות עם Snyk. אם מישהו נכשל, GitHub מציג X אדום בPS, וניתן לראות את התפוקה המלאה בלחיצה על "Details".

Bots לניהול PR אוטומטי

Bots מוצאים כאן יכולים לעשות דברים כמו: (1) אישור אוטומטי של PR כאשר כל התנאים מתקיימים, (2) merge אוטומטי, (3) ניהול labels (תגיות), (4) הקצאת reviewers, (5) תגובות אוטומטיות כמו "תודה על PR זה!" או "דא זקוק לעדכון כדי למזוג".

לדוגמה, אתה יכול להשתמש ב-Bots כמו "Dependabot" (ניהול עדכוני תלויות), "Semantic Pull Request" (בדיקת שם PR), או "Kodiak" (merge אוטומטי). אתה גם יכול לכתוב Bot משלך עם Actions ו-webhooks.

בטיחות: הגן על Secrets

כשמשתמשים ב-Actions, נכנסים tokens וסודות לרשת. תמיד שמרו אותם ב-GitHub Secrets, לא בקוד. אפילו אם ה-repo פרטי, אל תחוביה סודות בטקסט פשוט.

Merge strategies וGitHub automation

GitHub תומך בכמה אסטרטגיות merge: (1) Create a merge commit (משכנע קומיט merge), (2) Squash and merge (מוקדש קומיטים לאחד), (3) Rebase and merge (rebase ולא merge).

אתה יכול להגדיר כללים מוסדרים ברמת Repository תחת Settings → Merge strategies. לדוגמה, תוכל לקבוע ש-only "Squash and merge" מותרת, יכול למנוע "delete head branches automatically" (מחוק את branch עם ה-PR סיים), וכן הלאה.

לאוטומציה של merge, אתה יכול לכתוב Workflow שמריץ `gh pr merge` כאשר תנאים מתקיימים. לדוגמה: "אם כל הבדיקות עברו ויש אישור אחד מ-CodeRabbit, merge אוטומטית עם squash".

Review requests והקצאת reviewers

GitHub תומך בהקצאה אוטומטית של reviewers בהתבסס על code ownership. צרו קובץ CODEOWNERS בשורש:

# CODEOWNERS — קובץ להקצאת reviewers
# כל שינוי בקבצים האלה דורש ביקורת מ-user זה

/src/api/*                @backend-team
/src/ui/*                 @frontend-team
/src/tests/*              @qa-team
*.yml                     @devops-team
Dockerfile                @devops-team
      

עם CODEOWNERS, GitHub יהקצה אוטומטית את ה-reviewer הנכון בהתאם לקבצים שנערכו. אתה גם יכול להגדיר שדורש מספר מינימלי של אישורים לפני merge.

Auto-approve וAuto-merge

Auto-approve פירושו שגם אם יש כללים הדורשים ביקורת, Workflow מסוים יכול לאשר PR בעצמו. למשל, Dependabot ייצור PR לעדכון dependencies, וגם יכול לאשר את עצמו אם כל הבדיקות עברו. שימוש ב-auto-approve צריך להיות זהיר — רק עבור מקרים קטנים כמו עדכוני documentation או dependencies.

Auto-merge פירושו שכאשר כל התנאים מתקיימים (בדיקות עברו, ביקורות אושרו וכו'), ה-PR merge אוטומטית ללא התערבות אנושית נוספת. זה מאיץ את הריתום בדפדפות ויכול להקטין עיכובים.

GitLab CI/CD וממשל איכות

GitLab היא חלופה לGitHub שמתמקד בי-CI/CD בנוי. בעוד GitHub דורש GitHub Actions או שירותים חיצוניים, GitLab יש CI/CD בנטוי (built-in). המשמעות היא שיצרת .gitlab-ci.yml בריק הפרויקט, ו-GitLab מריץ אוטומטית בדיקות, בנייה ודפוס (deployment) עבור כל push וקובץ.

GitLab גם יש יכולות סקירת קוד בנוי. Merge Requests (MR) הוא מקביל של PR ב-GitHub. כאשר יוצרים MR, GitLab מריץ מיד CI pipeline וממלא את הקריטריונים (requirements). לדוגמה, ניתן להגדיר שדורש עברות בכל בדיקות ודירוג בטיחות מינימלי לפני merge. GitLab גם בעל Approval תהליכים מובנים, Label management, וכמה זרימי עבודה מתקדמים.

GitLab משמש יותר חברות גדולות כי הוא פחות תלוי בכלים חיצוניים. כמו כן, GitLab תמיד קוד פתוח, כך שחברות יכול להרים שרת GitLab בעצמן (Self-Hosted) בלי תלות בעננים ציבוריים.

GitLab features לסקירת קוד

GitLab מציע בנטוי: (1) Code Quality Reports — דוחות איכות בנויים לכל MR, (2) SAST (Static Application Security Testing) — קנטור בטיחות בנוי, (3) Dependency Scanning — בדיקת תלויות לחולשות ידועות, (4) Container Scanning — סקן תמונות Docker, (5) License Compliance — בדיקת רישיונות של תלויות.

כל הדוחות האלה מופיעים ב-Merge Request, כך ש-reviewer אנושי רואה מיד אם יש בעיות בטיחות או אם סוג קוד ירוד.

Merge Request Approvals

GitLab תומך ביצירת כללים מוגדרים לאישורים (approvals). לדוגמה: "דורש 2 אישורים מן backend-team ו-1 אישור מ-QA" או "דורש אישור מן code-owner של הקובץ שנערך".

# .gitlab/approval-rules.yml (יצור עם GitLab Web UI או API)
approval_rules:
  - name: Security
    rule_type: security
    approvals_required: 2
    eligible_approvers:
      - @security-team
  
  - name: Architecture
    rule_type: any_merge_request
    approvals_required: 1
    eligible_approvers:
      - @architects
      

ניתן גם להגדיר שרק מסוגים מסוימים של משתמשים יכול לאשר (למשל, לא ניתן לאשר PR שלך ברובו). זה משמר מפני "self-approval" וגוררים שוגיות.

פיצול בדיקות בין בוטים ובני אדם

בעוד בדיקות אוטומטיות (linting, unit tests, security scans) יכול להריץ בבוט, סוגים מסוימים של בדיקות דורשים אדם: ביקורת קוד, בדיקות ידניות (manual tests), בדיקות עיניות, ובדיקות UX. GitLab מאפשר לך להגדיר workflow שמוקצה על ידי בוט (CICD) ובחלקו על ידי בני אדם (reviews).

לדוגמה: (1) בוט מריץ לינט, יחידות בדיקות, סקן בטיחות, (2) אם הם כל העברות, בוט ממלא label "approved-by-bot", (3) review אנושי בודק קוד אחרון, הסקירה המנטליה ו-UX, (4) כאשר review אנושי מסיימים, הם מאשרים את MR, (5) אם כל התנאים מתקיימים, merge יכול להתרחש.

טיפ: GitLab CI/CD שפה

.gitlab-ci.yml היא ערוצים בניית מוגבלים של GitHub Actions — היא יותר פשוטה אך יותר חזקה עבור CI/CD בעיתות (pipelines). למדו ה-YAML structure בעיון — זה קידוח החזקה שלכם.

דוחות וניתוח PR

דשבורד GitLab מציג: (1) מספר MR פתוחים וממתינים, (2) זמן ממוצע מ-MR יצירה ל-merge, (3) מספר MR בחודש על ידי משתמש, (4) ציון ביצועים (throughput). אתה יכול ליפצר דוחות להבין אם הצוות משפיע על הרבה PR או מעטים, וכמה זמן לוקח לתהליך סקירה.

GitLab גם מציע "Analytics" תוך תבטיח. לדוגמה, אתה יכול לראות את ההיסטוריה של כל קובץ וכמה פעמים זה שונה. כל זה עוזר לתכנון וניתוח חולשות בתהליך הפיתוח.

Best Practices ופיתוח תרגול

לאחר שלמדתם את הכלים, זה זמן להוציא בפועל ולמעתה של אתה וזמן בו בחרתם, אתה צריך כללים חוקיים (best practices). אלה אינם רק טיפים — הם עקרונות שהוכחו בחברות גדולות כמו Google, Amazon, Meta, וטכנולוגיה אחרת מנהיגים.

Best practices עבור סקירת קוד עם AI כוללים: (1) תפקידים וגבולות ברורים בין בוט ואדם, (2) עכבה שוטפת לתהליך הסקירה, (3) תיעוד ויידע קוד, (4) בדיקות כתובות בזמן, (5) אמנה לתיקון באגים מהר מאשר תכונות חדשות.

בקורס זה, נתרגל הטמעה מלאה של סקירת קוד בממשל AI בפרויקט ממשי ובהלכה אמנה של עבודה בקטגוריות וקבוצות סיור. נלמד איך לטפל בכשלים, כיצד לעזור ל-developers, וכיצד להימנע מבעיות נפוצות.

תרגול: הגדרת סקירה מלאה באמצעות כלי AI

הבה נטרח מקרה מלא: פרויקט Node.js עם React frontend. צריך להגדיר: (1) Copilot בעלות מקומי ב-IDE, (2) CodeRabbit לביקורות PR, (3) SonarQube לסקן בטיחות ואיכות, (4) GitHub Actions לאוטומציה, (5) CODEOWNERS לתיוג (assignment).

שלב 1: הגדרת Copilot (כבר מכוסה במודול 2), שלב 2: התקנת CodeRabbit (כבר מכוסה במודול 3), שלב 3: התקנת SonarQube Cloud.

# שלב 3: הגדרת SonarQube ב-.github/workflows/sonar.yml
name: SonarQube
on: [push, pull_request]

jobs:
  build:
    runs-on: ubuntu-latest
    steps:
      - uses: actions/checkout@v3
        with:
          fetch-depth: 0
      - uses: actions/setup-node@v3
        with:
          node-version: 18
      - run: npm ci
      - run: npm run build
      - run: npm test -- --coverage
      - uses: SonarSource/sonarcloud-github-action@master
        env:
          GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
          SONAR_TOKEN: ${{ secrets.SONAR_TOKEN }}

# בקובץ sonar-project.properties:
sonar.projectKey=my-awesome-app
sonar.organization=my-org
sonar.sources=src
sonar.tests=src
sonar.test.inclusions=**/*.test.js
      

ממשל ואבטחה בקוד

ממשל קוד פירושו הגדרת כללים וקווים-מנחים אומצו לתוך קבוצה. כללים אלה יכול להיות כמו: "כל PR חייב בעלות 80% code coverage", "בעיות בטיחות קריטיות חוסמות merge", "דורש אישור קוד-owner לפני merge".

אבטחה היא חלק של ממשל. כללי אבטחה יכול להיות: "אסור hardcoded secrets", "בעיות בטיחות medium ומעלה חוסמות", "דורש בדיקה אבטחה מנוהלת לתכונות חדשות".

# CODEOWNERS לממשל בטיחות
/src/auth/*              @security-team
/src/database/*          @db-team
/src/payments/*          @payments-team
/.github/workflows/*     @devops-team
Dockerfile               @devops-team
sonarqube-project.properties  @qa-team
      

אתיקה וטבעיות של AI בסקירה

כאשר משתמשים בכלי AI לסקירה, חשוב להיות חכם (thoughtful) ואתי: (1) לא להסתמך 100% על AI — תמיד שימו סקירה אנושית, (2) להיות שקופים — אם בוט סקר PR, חשוף את זה (label או תגובה), (3) לנוח פקחות של טיסטה בנתונים אימון — כלי AI יכול להיות מוטים אם הם הודרכו על נתונים מובנים, (4) להחוק את הכללים — אם כלי AI עצי משהו, לעיתים קרובות זה לא תמיד נכון.

בקורא אחרון, אתה צריך לנוח שכלי AI משמש כעוזר למתכנתים, לא כממחה. המטרה היא לשחרר מתכנתים עבור עבודה בעלת ערך גבוה יותר, לא להחליף אותם.

קיצור זמן סקירה ושמירה על איכות

בחברות בעלות PR בהיקף גבוה, סקירה יכול להיות병목. אוטומציה עם כלי AI יכול לקטון זמן סקירה בעד 50-70% בעוד שומרת איכות. הנה טכניקות:

(1) הפצה אוטומטית של PR ל-reviewers הנכונים (CODEOWNERS), (2) סקן אוטומטי של בעיות לא-סקירה (linting, בדיקות יחידה, סקן בטיחות), (3) סקירה מקדימה על ידי בוט (CodeRabbit) כדי להדגיש בעיות, (4) בלוק merge אם בדיקות לא עוברות, (5) auto-merge עבור PR בטוחים (קטנים, לא בעלי סיכון גבוה).

טיפ: Reviewer Rotation

בחברות גדולות, rotation reviewers כדי להימנע מעומס על מישהו אחד. CODEOWNERS יכול להיות רשימת אנשים, ו-GitHub בוחר אחד רנדומלי. זה מקל ושומר את כל מישהו עדכון בקוד שלם.

פתרון בעיות נפוצות

בעיות נפוצות ותיקים להן:

בעיה: SonarQube מדווח על "false positives" (אזהרות שלא בעלות חשיבות). פתרון: תיקו את כללי SonarQube (rules) ב-SonarQube Admin Panel — ציין איזה כללים חשובים באמת לצוות שלכם.

בעיה: CodeRabbit מעיר הערות שלא רלוונטיות לסך פרויקט. פתרון: צרו .coderabbit.yaml וקביעו כללים מותאמים (custom rules). בנוסף, "dismiss" הערות שלא רלוונטיות — CodeRabbit לומד מן ההערות.

בעיה: PR בהיקף גדול (1000+ lines) גורמת לאוטומציה להיות איטית. פתרון: עודדו "smaller PRs" בתוך הצוות. PRs קטנים (100-300 lines) הם טובים יותר לסקירה ו-merge, וגם לאוטומציה.

בעיה: Reviewers לא מתגובבים בזמן, PR יושבות בתור. פתרון: הגדרו SLA (Service Level Agreement) — לדוגמה, "בדוקה בתוך 24 שעות". אם מישהו לא מגיבים בזמן, escalate אל Team Lead או השתמשו ב-auto-assign קטנים (עבור PRs קטנים, פחות הקפדה על SLA).

פרויקט סיום — הטמעה בעולם אמיתי

בפרויקט הסיום, תוקדידו הטמעה מלאה של סקירת קוד מנומר בממשל AI בפרויקט ממשי או סימולציה של פרויקט. זה יהיה בדיקה מעשית של כל מה שלמדתם: הגדרת כלים, כתיבת Workflows, ניהול PR, ותעוד. על ידי סיום פרויקט זה, תוכלו להטמיע את זה בחברה שלכם בביטחון.

פרויקט זה יתחלק לשלוש פעולות: הגדרה (setup), בדיקה (testing), ותעוד/הדרכה. כל פעולה לובשת קטגוריה בדירוג מסוים.

בחירת כלים מתאימים לפרויקט

ראשית, בחרו פרויקט בו תעבדו. יכול להיות: (1) פרויקט קיים בעבודה (אם יש לכם גישה), (2) פרויקט קוד פתוח מhub GitHub בו תוכלו לתרום, (3) פרויקט מו"ל שתיצרו לצורך זה (simple Todo app, blog, וכו').

שני, שקול אילו כלים הם הנכונים לפרויקט שלך: האם זה Node.js? בחרו ESLint, Jest, SonarQube, CodeRabbit, GitHub Actions. האם זה Python? בחרו Black, pylint, pytest, SonarQube, GitLab CI. תחשבו גם על הערוצים של צוות שלכם — אם הם GitHub, בחרו GitHub Actions; אם GitLab, בחרו GitLab CI.

שלישי, תרשמו את הדרישות: "אני רוצה לסקור 80% code coverage, zero critical security issues, אפס linting errors, וביקורת קוד מ-1 reviewer לפני merge". זה יהיה המטרות שלכם.

הגדרה מלאה של Pipeline

צעד 1: הגדרת Repository. אם אתה משתמש בGitHub: יצרו Repository חדש, אם שלך. הגדרו Default Branch (main), אבחרו "Add .gitignore" ו-"Add a README".

צעד 2: הגדרת Linting ו-Formatting. בפרויקט שלך, הוסיפו package.json (אם Node.js) ותקנו ESLint ו-Prettier:

npm install --save-dev eslint prettier @eslint-config-prettier
npx eslint --init
echo '{"printWidth": 100, "semi": true, "singleQuote": true}' > .prettierrc.json

# הוסיפו ל-package.json:
"scripts": {
  "lint": "eslint src/",
  "format": "prettier --write src/",
  "test": "jest --coverage"
}
      

צעד 3: הגדרת GitHub Actions. צרו .github/workflows/ci.yml:

name: CI Pipeline
on: [push, pull_request]

jobs:
  lint-and-test:
    runs-on: ubuntu-latest
    steps:
      - uses: actions/checkout@v3
      - uses: actions/setup-node@v3
        with:
          node-version: '18'
      - run: npm ci
      - run: npm run lint
      - run: npm run format --check
      - run: npm run test
      - run: npm run build

  security:
    runs-on: ubuntu-latest
    steps:
      - uses: actions/checkout@v3
      - uses: snyk/actions/node@master
        env:
          SNYK_TOKEN: ${{ secrets.SNYK_TOKEN }}
      

צעד 4: הגדרת CodeRabbit. התקנו את GitHub App מ-Marketplace.

צעד 5: הגדרת SonarQube. התחברו ל-SonarCloud, צרו Project, וקבלו token.

צעד 6: הגדרת CODEOWNERS.

# CODEOWNERS
* @[your-github-username]
/src/* @[your-github-username]
      

טסטינג וולידציה של השינויים

כעת, בדקו את ה-pipeline על ידי יצירת ענף בדיקה וביצוע שינויים:

צעד 1: צרו ענף בדיקה: `git checkout -b test/setup`

צעד 2: בצעו שינוי קטן בקוד (למשל, הוסיפו תגובה או קבץ README).

צעד 3: דחפו: `git push origin test/setup`

צעד 4: צרו Pull Request ב-GitHub. בדקו אם: CI pipeline רץ בהצלחה, CodeRabbit עושה סקירה, דשבורד GitHub מציג "All checks passed".

צעד 5: אם הכל עובר, merge ל-main.

צעד 6: בדקו שניצל commit בעולם main בטל, בדקו שכל ה-artifacts (קבצי בנייה) זמינים.

תיעוד והדרכה לצוות

צרו README.md ו-CONTRIBUTING.md בפרויקט שלכם, מתעדים את תהליך הסקירה המלא. צרו קטע בהוא שנראה כך:

# סקירת קוד והטמעת AI בפרויקט זה

## כלים בשימוש
- **GitHub Actions**: סקן לינט, בדיקות יחידה, סקן SonarQube
- **CodeRabbit**: סקירת PR בעל אוטומציה
- **SonarQube**: סקן בטיחות ואיכות קוד
- **Copilot**: עריכה חכמה בـ IDE

## תהליך PR
1. צרו branch חדש: `git checkout -b feature/my-feature`
2. בצעו שינויים, ודחפו
3. צרו PR וממתינים ל-checks
4. CodeRabbit יעשה סקירה אוטומטית
5. אם כל בדיקות עברו, בקשו ביקורת מן code-owner
6. כאשר אישור קבוע, merge
      

פרזנטציה וסיכום

לסיום פרויקט, הכינו מצגת קצרה (5-10 דקות) המתארת: (1) הפרויקט שבחרתם ותדגיקו שלו, (2) הכלים שהטמעתם ויוצאי-צאו, (3) דוגמה של PR ושינויים של pipeline, (4) דוחות SonarQube וביקורות CodeRabbit, (5) הצלחות וקללות אפשריות, (6) משימות צפויות בעתיד.

אם בקורס מנוהל, שתפו את הפרזנטציה עם המדריך והסטודנטים האחרים. אם בקורס עצמאי, תיעדו את כל בשוקל ב-GitHub (README + screenshots).

סיום קורס

בעתה זה, אתה יודע לרוץ קוד עם Copilot, סקור PR עם CodeRabbit, בדוק בטיחות עם SonarQube, וארגן הכל עם GitHub Actions. אתה מוכן להטמיע זה בצוות שלך!

שאלות נפוצות

האם אצטרך ידע בתכנות מקדים?

כן, רצוי שיהיה לך הכרה בסיסית של Git ו-GitHub/GitLab. הקורס מתאים לכל רמות הפיתוח — מהתחילים ועד למפתחים מנוסים. אם אתה מתחיל ב-Git, מומלץ לעבור דרך tutorial בסיסי של Git לפני הקורס.

האם הכלים בקורס חינמיים?

חלקם חינמיים (GitHub, GitLab) וחלקם בעלי גרסאות ניסיון חינמיות (CodeRabbit, SonarQube). GitHub Copilot דורש רכישה (אם לא זה סטודנט), אך כל שאר הכלים יש גרסאות חינמיות מלאות או בעלות free tier גדול. נוכל להשתמש בגרסאות הניסיון לצורך הקורס.

מה ההבדל בין CodeRabbit ל-Copilot?

Copilot הוא כלי עריכה בזמן-אמת שמשתמש בו כשאתה כותב קוד, בעודו CodeRabbit מתמחה בסקירת PR לאחר שהקוד נשמר. שניהם משלימים זה את זה — Copilot משפר את הקוד תוך כדי כתיבה, וCodeRabbit משמר אותו לפני merge.

כמה זמן לוקח ההטמעה בחברה?

בדרך כלל 2-4 שבועות להתקנה ותצורה ראשונית, בתלות בגודל הצוות והמורכבות של הפרויקט. התאמה אישית וקבלה בצוות יכול לקחת עוד חודש או שניים. התחילו קטן (כלי אחד) והוסיפו בהדרגה.

האם AI יכול להחליף סקירה ידנית?

לא לחלוטין. AI משפר את התהליך בדרך משמעותית, אך סקירה אנושית נשארת חיונית לאימות ולוגיקה עסקית. AI טוב במציאת באגים טכניים, אך אנשים טובים בהבנת כוונות, עיצוב, וטעם. צוות שמשתלב בוט וביקורות אנוש יהיה הטוב ביותר.

האם יש תמיכה בשפות תכנות אחרות?

כן! הרוב הגדול של הכלים תומכים ביותר משפות התכנות — Python, JavaScript, Java, Go, Rust, C++, C#, TypeScript, PHP, Ruby ועוד. SonarQube תומך ב-27+ שפות. בקורס, נשתמש בעיקר ב-JavaScript/TypeScript ו-Python כדוגמות, אך העקרונות חלים על כל שפה.