‫Google משתמשת בטכנולוגיית AI כדי לתרגם תוכן לשפה המועדפת עליך. בתרגומים כאלו עשויות להיות שגיאות.

שיפור איכות הקוד: בדיקת קוד בעזרת AI באמצעות Antigravity CLI ו-SDK

1. מבוא

תכנות בשיטת Vibe coding – שימוש בסוכני AI כדי לכתוב קוד מתוך הנחיות בשפה טבעית – משנה את התפקיד של המפתח מכותב למתזמר ולבודק. אנחנו מסתמכים על הכנת ההקשר המושלם וסומכים על סוכני ה-AI שיעשו בשבילנו את כל הדברים, החל מיצירת מסמכי המפרט ועד לווידוא שהקוד עומד בכל הדרישות. הסיכון: במחזורי איטרציה מהירים, קוד פונקציונלי מאושר ללא בדיקת אבטחה יסודית. סוכנים מודרניים מייצרים בדרך כלל קוד מאובטח כברירת מחדל, אבל 'בדרך כלל' לא אומר 'תמיד', ולכן חולשות מצטברות חומקות מבדיקה ידנית.

ב-Codelab הזה נסביר על שתי גישות לשימוש ב-Antigravity כבודק: באופן אינטראקטיבי במהלך הפיתוח באמצעות CLI (בודקים, מתקנים ואז שולחים בקשת מיזוג), ובאופן אוטומטי באינטגרציה רציפה באמצעות SDK (הסוכן בודק כל בקשת מיזוג ומפרסם את התוצאות כהערה).

מה תלמדו

השתמשתם בקידוד לפי אינטואיציה באפליקציית CRM לניהול לידים – סוכן AI בנה בשבילכם את כל המערכת: קצה עורפי של Express, מסד נתונים של SQLite וקצה חזיתי של React. זה עובד. לאחר מכן ביקשת מהסוכן להוסיף שתי תכונות חדשות: פונקציית חיפוש לידים וייבוא/ייצוא בכמות גדולה עם נתונים סטטיסטיים של האדמין. הסוכן סיפק את שניהם במהירות. הקוד פועל, התכונות פועלות ובקשות משיכה מוכנות.

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

בשיעור Codelab הזה מוצגות שתי דרכים לפתרון הבעיה:

תרחיש לדוגמה 1 – בדיקה אינטראקטיבית: יוצרים ענף תכונות עם נקודות חולשה, משתמשים ב-Antigravity CLI עם יכולות סוכן כדי לבדוק את ההשוואה, מתקנים את הבעיות ויוצרים בקשת מיזוג נקייה.
מקרה 2 – בדיקה אוטומטית: מגדירים GitHub Action שמבוסס על Antigravity SDK, שבודק אוטומטית בקשות משיכה, מפרסם ממצאים מובנים כתגובות ומגיב כשמפתחים שואלים שאלות המשך לגבי הבדיקה.

מה תלמדו

איך תכנות בשיטת Vibe coding עלול ליצור סיכוני אבטחה ומדוע בדיקה אוטומטית מאתרת בעיות שבדיקה ידנית לא מאתרת
איך להתקין ולהשתמש במיומנויות של סוכנים שמתעדכנות על ידי הקהילה כדי להעניק ל-Antigravity CLI מומחיות מעמיקה בתחום האבטחה וסקר הקוד
איך משתמשים ב-CLI באופן אינטראקטיבי כדי לבדוק את ההשוואה בין ענף תכונה, לתקן נקודות חולשה וליצור בקשת משיכה נקייה
איך משתמשים ב-Antigravity SDK כדי לבנות סוכן לסקר קוד לקריאה בלבד עם מדיניות אבטחה הצהרתית ו-lifecycle hooks
איך פורסים את סוכן הביקורת כ-GitHub Action שבודק בקשות משיכה ומפרסם את התוצאה כתגובה לבקשת המשיכה

דרישות מוקדמות

חשבון Google Cloud
חשבון GitHub
היכרות בסיסית עם Terminal, בקרת גרסאות ו-CI/CD

2. הגדרת הסביבה

בשלב הזה מתבצע פיצול של מאגר האפליקציה Leads CRM, שיבוט שלו ב-Cloud Shell, הגדרה של Antigravity CLI ואימות.

חיבור מאגר

אתם צריכים עותק משלכם של המאגר כי תדחפו התחייבויות ותיצרו בקשות למשיכת שינויים באמצעות GitHub Actions.

עוברים אל המאגר הבא

אחר כך לוחצים על Fork. בדף ליצירת הפיצול, מבטלים את הסימון של התיבה 'העתקה של הענף main בלבד' – צריך לכלול בפיצול את ענפי התכונות האחרים (feature/lead-search ו-feature/bulk-operations).

פתיחת Cloud Shell

פותחים את Cloud Shell בדפדפן. ‫Cloud Shell מספקת סביבה שהוגדרה מראש עם כל הכלים שדרושים ל-Codelab הזה. כשמוצגת בקשה, לוחצים על Authorize

אחר כך לוחצים על View (תצוגה) -> Terminal (טרמינל) כדי לפתוח את הטרמינל.הממשק אמור להיראות בערך כך:

זה יהיה הממשק הראשי שלנו, סביבת הפיתוח המשולבת (IDE) בחלק העליון והטרמינל בחלק התחתון

אימות באמצעות GitHub

כברירת מחדל, ב-Cloud Shell לא מוגדרים פרטי כניסה ל-GitHub, אבל כבר מותקן בו gh CLI. מגדירים אימות כדי שיהיה אפשר לשלוח קומיטים וליצור בקשות למשיכת שינויים בהמשך:

gh auth login

בחירת Github.com

בוחרים באפשרות HTTPS ( או באפשרות אחרת אם אתם מכירים מנגנון אחר)

לאחר מכן, בוחרים באפשרות Y.

לאחר מכן, בוחרים באפשרות Login with a web browser.

**,**תתבקשו להעתיק את הקוד החד-פעמי ולהזין אותו כשפותחים את דף הכניסה בדפדפן. אפשר Ctrl + Click על כתובת ה-URL במסוף כדי לפתוח את כתובת ה-URL של https://github.com/login/device. תתבקשו לבחור את החשבון שאליו אתם רוצים להתחבר ולהזין את הקוד.

אחרי זה, חוזרים לדף של מסוף Cloud Shell ורואים את פלט הטרמינל כמו בדוגמה הבאה

✓ Authentication complete.
- gh config set -h github.com git_protocol https
✓ Configured git protocol
! Authentication credentials saved in plain text
✓ Logged in as alphinside-joonix

כלומר, הגדרתם בהצלחה את האימות של חשבון GitHub ב-Cloud Shell.

שיבוט של המאגר המפוצל

בשלב הבא, משכפלים את המאגר המפוצל. מחליפים את <YOUR_GITHUB_USERNAME> בשם המשתמש שלכם ב-GitHub:

git clone https://github.com/<YOUR_GITHUB_USERNAME>/leads-crm-app-demo.git
cloudshell workspace leads-crm-app-demo && cd leads-crm-app-demo

אימות של ענפי תכונות

לאחר מכן, מוודאים ששני ענפי התכונות עם נקודות החולשה המובנות זמינים במאגר המרוחק:

git branch -a | grep feature/

הפלט הבא אמור להתקבל

remotes/origin/feature/bulk-operations
remotes/origin/feature/bulk-operations-solution
remotes/origin/feature/email-composer
remotes/origin/feature/lead-search

אימות של Antigravity CLI

עכשיו נבדוק ש-Antigravity CLI מותקן מראש ב-Cloud Shell. כדי לבדוק אם האפשרות זמינה:

agy --version

אמורה להופיע גרסת Antigravity CLI שהותקנה, למשל 1.0.13

אם עדיין לא אימתתם את Antigravity CLI, תוכלו לעבור אל ה-codelab הזה כדי לראות את תהליך האימות בפירוט.

בשלב הזה אמורים להיות לכם הפרטים הבאים:

המאגר המפוצל משוכפל
שני הענפים של הפיצ'רים גלויים
פקודת agy זמינה ומאומתת

3. הבעיה – נקודות חולשה שמוסתרות בתכונות עם קוד Vibe

הנה תרחיש לדוגמה: חבר צוות השתמש בסוכן AI כדי להוסיף שתי תכונות לאפליקציית Leads CRM – פונקציית חיפוש לידים ופעולות ייבוא/ייצוא בכמות גדולה. שתי התכונות פועלות. שניהם נשלחו במהירות בלי בדיקת אבטחה. תבדקו את שני הענפים לפני המיזוג שלהם – אחד באופן אינטראקטיבי באמצעות ה-CLI, והשני באופן אוטומטי באמצעות GitHub Action.

בדיקת הענף הראשון של התכונה

בודקים את ההשוואה ב-feature/lead-search:

git diff main...origin/feature/lead-search

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

+  app.get("/api/leads/search", (req, res) => {
+    const query = req.query.q as string;
+
+    if (!query) {
+      return res.status(400).json({ error: "Search query is required" });
+    }
...

בדיקת הענף השני של התכונה

git diff main...origin/feature/bulk-operations

בסניף הזה נוספו נקודות קצה לייבוא/ייצוא בכמות גדולה ומרכז בקרה לסטטיסטיקות של אדמינים. הפגיעויות כאן כוללות פרטי כניסה של אדמין בתוך הקוד, נקודות קצה של אדמין שלא מאומתות, אימות קלט לא תקין בייבוא בכמות גדולה וסיכון של Path traversal בטיפול בשם הקובץ של הייצוא.

...
+  const ADMIN_PASSWORD = "admin123";
+
+  app.post("/api/admin/import", (req, res) => {
+    const { password, leads } = req.body;
+
+    if (password !== ADMIN_PASSWORD) {
+      return res.status(401).json({ error: "Invalid admin password" });
+    }
...

שני הענפים מוסיפים תכונות פונקציונליות. בשניהם יש בעיות אבטחה. השאלה היא איך לזהות אותם – באופן ידני באמצעות ה-CLI (מקרה 1) או באופן אוטומטי באמצעות GitHub Action (מקרה 2).

4. מקרה 1 : בדיקה אינטראקטיבית באמצעות Antigravity CLI

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

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

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

בשלב הזה משתמשים ב-Antigravity CLI עם כישורי סוכנים כדי לבדוק את הענף feature/lead-search, לתקן את נקודות החולשה וליצור בקשת משיכה נקייה.

בדיקת ענף התכונה

קודם כל, נשנה את הענף לענף Case 1:

git checkout feature/lead-search

עכשיו נשדרג את Antigravity CLI עם מיומנויות הסוכן כדי לבצע בדיקה

מהן המיומנויות של הסוכן

מיומנויות הן קובצי Markdown הצהרתיים שמעניקים לסוכן מומחיות ייעודית. אחרי ההתקנה, הן הופכות לפקודות עם לוכסן (למשל, /code-review-and-quality). אפשר לחשוב עליהן כעל מדריך אבטחה של מהנדס בכיר לסוכן למטרות כלליות.

אפשר להעביר מיומנויות בין סוכנים (Antigravity,‏ Claude Code,‏ Cursor וכו') ולשתף אותן באמצעות Git. ב-Antigravity CLI, מיומנויות של סביבת עבודה (פרויקט/מקומי) נמצאות ב-.agents/skills/ בספריית הבסיס של הפרויקט. לעומת זאת, מיומנויות גלובליות נמצאות ב-~/.gemini/config/skills/. מידע נוסף מופיע במאמר הזה

כדי להדגים את היכולות של מיומנויות סוכן, ב-Codelab הזה נשתמש במיומנות של סקר קוד מ-addyosmani/agent-skills:

‫code-review-and-quality – בדיקה של חמישה צירים (נכונות, קריאות, ארכיטקטורה, אבטחה וביצועים) עם תיוג חומרת הבעיה.

התקנת מיומנות של סוכן סקר קוד

באמצעות הפקודה שבהמשך, הכישורים יותקנו ב-.agents/skills/ כברירת מחדל בספריית העבודה הנוכחית – התקנה ברמת סביבת העבודה. המשמעות היא שהם הופכים לחלק מהמאגר ואפשר לבצע commit שלהם לצד הקוד, כך שכל מפתח (ופייפליין CI) בפרויקט מקבל אוטומטית את אותן יכולות בדיקה.

npx skills add addyosmani/agent-skills --skill code-review-and-quality -y

כך נראים הפרטים של המיומנות שאפשר לבדוק בקובץ .agents/skills/code-review-and-quality/SKILL.md:

name: code-review-and-quality
description: Conducts multi-axis code review. Use before merging any change. Use when reviewing code written by yourself, another agent, or a human. Use when you need to assess code quality across multiple dimensions before it enters the main branch.

יכולות עיקריות:

ביקורות בחמישה תחומים: נכונות, קריאות, ארכיטקטורה, אבטחה וביצועים
התוצאות מתויגות לפי חומרת הבעיה, כדי שתוכלו לפתור קודם את הבעיות הקריטיות
החלת תקן האישור: "אישור אם יש שיפור ברור בתקינות הכוללת של הקוד, גם אם הוא לא מושלם"

עכשיו אפשר להתחיל להריץ את הקוד. איך מאמתים את המיומנות ב-Antigravity CLI

הפעלת AGY ואימות מיומנויות

הפעלת Antigravity CLI

agy --dangerously-skip-permissions

לאחר מכן מריצים את הפקודה הבאה

/skills

שני הכישורים אמורים להופיע כך בקטע Workspace skills

הרצת בדיקת הקוד של ההבדלים בתכונה

מפעילים את מיומנות האבטחה ומבקשים ממנה לבדוק את הענף. מקלידים את הפרומפט הבא:

Review the git diff between main and my current branch. Find any issues based on the agent skills that are appropriate for this. Write the findings and plan to fix them to code_review.md in the current working directory. Do not apply fixes yet.

הסוכן מזהה את המיומנות code-review-and-quality שרלוונטית ומפעיל אותה באופן אוטומטי. הוא קורא את ההבדלים, מזהה נקודות חולשה וכותב את הממצאים עם תוכנית תיקון מוצעת ל-code_review.md.

אחרי שהסריקה מסתיימת, קובץ code_review.md נוצר בספריית העבודה ואפשר לבדוק אותו בעורך

בודקים כל ממצא ואת התיקון המוצע. כשתהיו מרוצים מהתוכנית, תבקשו מהסוכן להחיל אותה:

Apply the proposed fixes from code_review.md

הסוכן קורא את התוכנית ומחיל כל תיקון מתוכנן על קובצי המקור.

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

npm install
npm run dev

האפליקציה אמורה לפעול בצורה תקינה. אם לא, אפשר לחזור על הפעולה ולבקש מ-Antigravity CLI לתקן את הבעיה.

ביצוע Commit ויצירת בקשת משיכה

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

קודם צריך להגדיר את הזהות שלכם ב-Git (מחליפים את השם וכתובת האימייל בשם ובכתובת שלכם), אם עדיין לא עשיתם זאת:

git config --global user.email "you@example.com"
git config --global user.name "Your Name"

לאחר מכן שומרים את השינויים.

git add .
git commit -m "fix: address security vulnerabilities in lead search feature"

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

5. מקרה 2 : בדיקה אוטומטית באמצעות Antigravity SDK – חלק 1 ( יצירת הסוכן)

בשלב הזה יוצרים סוכן לבדיקה אוטומטית באמצעות Antigravity SDK, פורסים אותו כ-GitHub Action ובודקים אותו מול הענף השני של התכונה. הסוכן בודק בקשות משיכה לפי דרישה ומפרסם את הממצאים כתגובות לבקשות משיכה.

למה אנחנו משתמשים בבדיקה אוטומטית

בדיקת CLI אינטראקטיבית (מקרה 1) פועלת כשהמפתח בודק באופן פעיל. צוותים צריכים בדיקה שמופעלת אוטומטית בכל בקשת מיזוג – כדי לזהות בעיות מכל תורם, מכל כלי ובכל זמן. ‫Antigravity SDK‏ (google-antigravity) מספק את אותו זמן ריצה של סוכן כמו CLI, בתור ספריית Python. הגדרת המדיניות וה-hooks מתבצעת בקוד.

‫GitHub Actions היא פלטפורמת אינטגרציה רציפה (CI) ופיתוח רציף (CD) מובנית של GitHub. הוא מריץ תהליכי עבודה – סקריפטים אוטומטיים שמוגדרים ב-YAML – בתגובה לאירועים במאגר כמו פתיחת בקשת מיזוג, שליחת קומיט או פרסום תגובה. תהליכי העבודה פועלים במכונות וירטואליות שמתארחות ב-GitHub ויש להם גישה לקוד המאגר. במקרה הזה, משתמשים ב-GitHub Action כדי להריץ סוכן לבדיקת אבטחה בכל פעם שנוצר PR.

כך פועל תהליך הבדיקה האוטומטי:

‫Antigravity SDK‏ ( google-antigravity) מספק את אותו זמן ריצה של סוכן כמו CLI, כספריית Python. אתם כותבים סקריפט Python שמגדיר את הסוכן עם מדיניות ו-hooks, מפעילים פתרונות חכמים בתוך GitHub Action ומפרסמים את התוצאות כתגובה ל-PR.

קבלת מפתח Gemini API

לפני שמתחילים, צריך להשתמש במפתח Gemini API ב-Antigravity SDK. עוברים אל מפתח API של Google AI Studio ויוצרים מפתח API. אפשר להעתיק את מפתח ה-API בכל שלב.

המפתח הזה ישמש להפעלת סוכן הבדיקה באופן מקומי, ובהמשך כסוד ב-GitHub Actions.

חלק א': בניית סוכן הבדיקה

עכשיו, במקרה 2, מעבירים את ספריית העבודה הנוכחית לענף feature/bulk-operations:

git checkout feature/bulk-operations

זהו הענף השני של התכונה מהתרחיש – הוא מוסיף נקודות קצה לייבוא/ייצוא בכמות גדולה ולוח בקרה של נתונים סטטיסטיים לאדמין באפליקציית ה-CRM.

הגדרת פרויקט Python

נכון לעכשיו, Antigravity SDK זמין רק ב-Python, ולכן נצטרך סביבת Python כדי לפתח אותו. נשתמש ב-uv בשביל מנהל הפרויקטים שלנו ב-Python. ‫uv הוא מנהל פרויקטים וחבילות Python מהיר שנכתב ב-Rust ( מסמכים). בשיעור Codelab הזה נשתמש בו כדי להסביר על הנושא במהירות ובפשטות. אם משתמשים ב-Cloud Shell לצורך המדריך הזה, הוא כבר מותקן מראש במופע. במדריך הזה מוסבר איך להתקין את התוסף במחשב

מאתחלים פרויקט Python לסוכן הבדיקה באמצעות uv:

uv init code_review_agent
uv add --project code_review_agent google-antigravity==0.1.7

תיווצר ספרייה חדשה code_review_agent שתכיל את הקבצים של סוכן סקר הקוד.

התקנת כישורי הביקורת

הסוכן שבודק את הקוד צריך להיות בעל אותן מיומנויות של אבטחה וסקר קוד שנדרשו בתרחיש 1. מתקינים אותם ב-code_review_agent/skills/ כדי שהסוכן של ה-SDK יטען אותם בזמן הריצה:

npx skills add addyosmani/agent-skills --skill code-review-and-quality -y
cp -r .agents/skills code_review_agent/skills

יצירת סוכן לביקורת

עכשיו ניצור את code_review_agent/review_agent.py . מריצים את הפקודה הבאה

cloudshell edit code_review_agent/review_agent.py

לאחר מכן, מעתיקים את התוכן הבא לקובץ

#!/usr/bin/env python3
import asyncio
import json
import os
import sys

import pydantic

from google.antigravity import Agent, LocalAgentConfig, CapabilitiesConfig
from google.antigravity.hooks import hooks, policy
from google.antigravity import types


class Finding(pydantic.BaseModel):
    file: str
    line: int
    severity: str
    category: str
    description: str
    proposed_fix: str = ""


class ReviewResult(pydantic.BaseModel):
    findings: list[Finding]


SCRIPT_DIR = os.path.dirname(os.path.abspath(__file__))
OUTPUT_FILE = "code_review.md"
SKILLS_PATHS = [
    os.path.join(SCRIPT_DIR, "skills", "code-review-and-quality"),
]

review_policies = [
    policy.deny_all(),
    policy.allow("view_file"),
    policy.allow("list_directory"),
    policy.allow("search_directory"),
    policy.allow("find_file"),
    policy.allow("run_command"),
    policy.allow("finish"),
]

@hooks.post_tool_call
async def log_tool_results(data: types.ToolResult):
    result_str = str(data.result) if data.result else ""
    preview = result_str[:200] + "..." if len(result_str) > 200 else result_str
    print(f"[audit] tool={data.name} result_len={len(result_str)} error={data.error} preview={preview}", flush=True)

@hooks.pre_tool_call_decide
async def enforce_safe_tools(data: types.ToolCall) -> types.HookResult:
    print(f"[audit] calling tool={data.name} args_keys={list(data.args.keys())}", flush=True)

    if data.name == "run_command":
        cmd = str(data.args.get("CommandLine", ""))
        if not cmd.startswith("git "):
            return types.HookResult(
                allow=False,
                message=f"Only git commands are allowed. Blocked: {cmd}"
            )
    return types.HookResult(allow=True)

async def review_code(target_dir: str) -> dict:
    prompt = f"""Run `git diff main...HEAD -- ':!.github' ':!code_review_agent'` in {target_dir} to get the changes on this branch.
Review ONLY the changed code for security vulnerabilities and code quality issues.
"""

    config_kwargs = dict(
        system_instructions=(
            "You are a code review agent. "
            "You review code diffs for vulnerabilities and quality issues using the loaded skills. "
            "You can run git commands to inspect the diff. "
            "You NEVER modify files."
        ),
        response_schema=ReviewResult,
        skills_paths=SKILLS_PATHS,
        policies=review_policies,
        hooks=[log_tool_results, enforce_safe_tools],
    )

    if os.environ.get("GEMINI_API_KEY"):
        config_kwargs["api_key"] = os.environ["GEMINI_API_KEY"]
    else:
        config_kwargs["vertex"] = True
        config_kwargs["project"] = os.environ.get("GOOGLE_CLOUD_PROJECT")
        config_kwargs["location"] = os.environ.get("GOOGLE_CLOUD_LOCATION", "global")

    config = LocalAgentConfig(**config_kwargs)

    async with Agent(config) as agent:
        response = await agent.chat(prompt)

        last_step = -1
        final_text_chunks = []
        async for chunk in response.chunks:
            if isinstance(chunk, types.ToolCall):
                final_text_chunks.clear()
            if hasattr(chunk, "text") and hasattr(chunk, "step_index"):
                if chunk.step_index != last_step:
                    final_text_chunks.clear()
                    last_step = chunk.step_index
                final_text_chunks.append(chunk.text)

        final_text = "".join(final_text_chunks)
        if final_text:
            print(final_text)

        data = await response.structured_output()

        if data and "findings" in data:
            return {"findings": data["findings"]}

        try:
            parsed = json.loads(final_text)
            if isinstance(parsed, list):
                return {"findings": parsed}
            if isinstance(parsed, dict) and "findings" in parsed:
                return {"findings": parsed["findings"]}
        except json.JSONDecodeError:
            pass

    return {"findings": final_text}


SEVERITY_EMOJI = {"critical": "🔴", "high": "🟠", "medium": "🟡", "low": "🔵"}

def format_markdown(result: dict) -> str:
    findings = result.get("findings", [])
    if isinstance(findings, str):
        return f"## AI Security Review\n\n{findings}\n"
    if not findings:
        return "## AI Security Review\n\nNo security issues found.\n"
    lines = ["## AI Security Review\n"]
    for f in findings:
        emoji = SEVERITY_EMOJI.get(f.get("severity", "").lower(), "⚪")
        lines.append(f"### {emoji} [{f.get('severity', 'unknown').upper()}] {f.get('category', '')}\n")
        lines.append(f"**{f.get('file', '')}:{f.get('line', '')}**\n")
        lines.append(f"{f.get('description', '')}\n")
        proposed_fix = f.get('proposed_fix', '')
        if proposed_fix:
            lines.append(f"**Proposed fix:** {proposed_fix}\n")
    lines.append("---\n*Powered by Antigravity SDK*")
    return "\n".join(lines)


if __name__ == "__main__":
    target = sys.argv[1] if len(sys.argv) > 1 else "."
    result = asyncio.run(review_code(target))
    markdown = format_markdown(result)
    with open(OUTPUT_FILE, "w") as f:
        f.write(markdown)
    print(f"Review written to {OUTPUT_FILE}")
    print(json.dumps(result, indent=2))

תסביר לי את ההחלטות העיקריות שקיבלת לגבי העיצוב של הסוכן הזה:

מדיניות של דחייה כברירת מחדל: policy.deny_all() חוסמת הכול, ואז מאפשרת באופן ספציפי רק כלים לקריאת קבצים ו-run_command (ל-git).
אכיפה בשתי שכבות: כללי המדיניות מגבילים ברמת המסגרת, וה-hook‏ enforce_safe_tools מספק שכבה שנייה – ומאפשר רק פקודות git דרך run_command .
היקף ההשוואה ב-Git: הסוכן מריץ את הפקודה git diff main...HEAD כדי לבדוק רק את הקוד ששונה, ולא את כל בסיס הקוד.
‫Structured output with fallback: response_schema=ReviewResult הפרמטר הזה מאלץ מבנה JSON באמצעות כלי הסיום של ה-SDK. אם הניתוח נכשל, שרשרת גיבוי (fallback chain) מנסה לנתח את text() כ-JSON, ואז מחזירה טקסט גולמי.
Auth fallback: משתמש ב-GEMINI_API_KEY אם הוא זמין, אחרת חוזר ל-Vertex AI באמצעות Application Default Credentials.
פלט קובץ: כותב ממצאים בפורמט Markdown ל-code_review.md – פעולת GitHub קוראת את הקובץ הזה ומפרסמת אותו כתגובה לבקשת משיכה בהמשך

בדיקת סוכן הבדיקה

בודקים משורש הפרויקט. ה-SDK יקרא את GEMINI_API_KEY מהסביבה, ולכן צריך להזין את המפתח בסביבה

export GEMINI_API_KEY=YOUR_API_KEY

לאחר מכן מריצים את הפקודה הבאה כדי להפעיל אותה באופן מקומי

uv run --project code_review_agent code_review_agent/review_agent.py .

במהלך ההפעלה יוצג פלט מסוים במסוף עם הסבר על הכלים שבהם נעשה שימוש כרגע. אפשר לראות שהסוכן ניגש למיומנויות security-and-hardening ו-code-review-and-quality

[audit] calling tool=view_file args_keys=['AbsolutePath', 'IsSkillFile']
[audit] tool=view_file result_len=47 error=None preview=Read security and hardening skill documentation
[audit] calling tool=view_file args_keys=['AbsolutePath', 'IsSkillFile']
[audit] tool=view_file result_len=48 error=None preview=Read code review and quality skill documentation
[audit] calling tool=run_command args_keys=['CommandLine', 'Cwd', 'WaitMsBeforeAsync']
...

הסוכן מריץ את הפקודה git diff main...HEAD, בודק רק את הקוד ששוּנה, כותב את הממצאים בפורמט code_review.md ומדפיס JSON מובנה במסוף. אפשר לבדוק את הטקסט שנוצר code_review.md בכלי העריכה, כמו שמוצג בהמשך

הוא כבר פועל באופן מקומי, ועכשיו נעבור לחלק הבא. יצירת ההגדרה של GitHub Action

6. מקרה 2 : בדיקה אוטומטית באמצעות Antigravity SDK – חלק 2 ( הגדרת פעולות ב-GitHub)

לפני שמתחילים, צריך למחוק את קובץ code_review.md שנוצר קודם, אם הוא קיים.

rm -f code_review.md

עכשיו צריך ליצור את קובץ ההגדרות של GitHub Action בפורמט YAML.

mkdir -p .github/workflows
cloudshell edit .github/workflows/code_review.yml

אחר כך מוסיפים את התוכן הבא לקובץ

name: AI Code Security and Quality Review

on:
  pull_request:
    types: [opened, synchronize]

jobs:
  review:
    runs-on: ubuntu-latest
    permissions:
      contents: read
      pull-requests: write

    container:
      image: ghcr.io/astral-sh/uv:python3.12-bookworm

    steps:
      - name: Install git
        run: apt-get update && apt-get install -y git
      - uses: actions/checkout@v4
        with:
          fetch-depth: 0
      - name: Run security review
        env:
          GEMINI_API_KEY: ${{ secrets.GEMINI_API_KEY }}
        run: |
          git config --global --add safe.directory $GITHUB_WORKSPACE
          uv run --project code_review_agent code_review_agent/review_agent.py .
      - name: Post findings as PR comment
        if: always()
        uses: actions/github-script@v7
        with:
          script: |
            const fs = require('fs');
            const body = fs.readFileSync('code_review.md', 'utf8');
            await github.rest.issues.createComment({
              owner: context.repo.owner,
              repo: context.repo.repo,
              issue_number: context.payload.pull_request.number,
              body: body
            });

תהליך העבודה יופעל אוטומטית כשתיפתח או תתעדכן בקשת מיזוג. הוא מוציא את הענף של בקשת משיכת השינויים עם היסטוריית git מלאה (נדרש ל-git diff main...HEAD), מריץ את סוכן הבדיקה שכותב את הממצאים ל-code_review.md, ומפרסם את תוכן הקובץ כתגובה לבקשת משיכת השינויים.

עכשיו נבצע commit של כל השינויים ונדחוף אותם למאגר המרוחק ב-GitHub. אנחנו מוכנים לבדוק את השילוב הזה.

git add .
git commit -m "Add AI code security-quality review agent and GitHub Action"
git push origin feature/bulk-operations

7. מקרה 2 : בדיקה אוטומטית באמצעות Antigravity SDK – חלק 3 (בדיקת בדיקת קוד אוטומטית)

עכשיו עוברים לדף האינטרנט של המאגר המחובר https://github.com/<YOUR_GITHUB_USERNAME>/leads-crm-app-demo ולוחצים על Settings

אחר כך, בחלונית הימנית, מחפשים את Secrets and variables, לוחצים עליו ובוחרים באפשרות Actions.

אחרי זה לוחצים על New repository secret כדי להגדיר GEMINI_API_KEY סוד

אחרי זה בוחרים באפשרות Pull Request ויוצרים בקשת משיכה חדשה מהענף feature/bulk_operations לענף main במאגר שלכם.

אחרי שיוצרים את בקשת המשיכה, יופעלו פעולות Github שאפשר לבדוק בתפריט Checks או ליד הלחצן Merge pull request.

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

8. סיכום

מזל טוב!

יצרתם שני תהליכי עבודה מלאים של סקר קוד, כדי לזהות פרצות אבטחה בתכונות עם קוד Vibe:

מקרה 1 (אינטראקטיבי): Antigravity CLI עם כישורי סוכן בדק את ההשוואה בענף של תכונה, זיהה הזרקת SQL ונקודות חולשה אחרות, תיקן אותן לפי דפוסי OWASP ויצר בקשת מיזוג נקייה.
מקרה 2 (אוטומטי): Antigravity SDK הפעיל GitHub Action שבודק באופן אוטומטי כל בקשת משיכה ומפרסם ממצאי אבטחה מובנים כתגובות לבקשת המשיכה.

מה למדתם

איך תכנות בשיטת Vibe coding יוצר סיכוני אבטחה ולמה בדיקה אוטומטית מאתרת בעיות שבדיקה ידנית לא מזהה
איך להתקין ולהשתמש בכישורי סוכן כדי לתת ל-Antigravity CLI מומחיות מובנית בתחום האבטחה
איך בודקים באופן אינטראקטיבי את ההשוואה בין הסתעפות תכונה, פותרים בעיות ויוצרים בקשת משיכה נקייה
איך יוצרים סוכן ביקורות לקריאה בלבד באמצעות Antigravity SDK, תוך שימוש במדיניות של דחייה כברירת מחדל וב-lifecycle hooks
איך פורסים צינור אוטומטי לעיבוד נתונים של בדיקות כפעולת GitHub עם תמיכה אינטראקטיבית למעקב

פינוי נפח

סגירת ה-PR

עוברים לכל בקשת מיזוג במזלג ב-GitHub ולוחצים על Close pull request (סגירת בקשת המיזוג). אל תמזגו את בקשת משיכת השינויים feature/bulk-operations – היא עדיין מכילה את הקוד הפגיע שלא תוקן.

מחיקת המאגר המפוצל (אופציונלי)

אם אין לכם יותר צורך בפיצול, עוברים לפיצול ב-GitHub: הגדרות -> גוללים אל אזור הסכנה -> מחיקת המאגר הזה.

השלבים הבאים

Antigravity CLI Plugins & Skills – create custom skills and plugins
הרשאות וארגז חול ב-Antigravity CLI – מדיניות כלים מפורטת וארגז חול ברמת מערכת ההפעלה
Antigravity SDK Hooks & Policies – advanced patterns (rate limiting, error recovery, middleware)
דוגמאות ל-Antigravity SDK – agent_middleware.py לדפוסי ייצור