Popraw jakość kodu: weryfikacja kodu wspomagana przez AI za pomocą Antigravity CLI i pakietu SDK

1. Wprowadzenie

Vibe coding – używanie agentów AI do pisania kodu na podstawie promptów w języku naturalnym – zmienia rolę programisty z autora na koordynatora i recenzenta. Polegamy na przygotowaniu idealnego kontekstu i ufamy agentom AI, że wykonają za nas wszystkie czynności, od tworzenia dokumentów specyfikacji po zapewnienie, że kod spełnia wszystkie wymagania. Ryzyko: w przypadku szybkich cykli iteracji funkcjonalny kod jest zatwierdzany bez dokładnej weryfikacji zabezpieczeń. Nowoczesne agenty często domyślnie generują bezpieczny kod, ale „często” nie oznacza „zawsze”, a nagromadzone luki w zabezpieczeniach mogą umknąć podczas ręcznej weryfikacji.

To ćwiczenie rozwiązuje te problemy, przedstawiając 2 sposoby korzystania z Antigravity jako recenzenta: interaktywnie podczas tworzenia za pomocą interfejsu wiersza poleceń (sprawdzasz, poprawiasz, a potem tworzysz żądanie scalenia) i automatycznie w ramach ciągłej integracji za pomocą pakietu SDK (agent sprawdza każde żądanie scalenia i publikuje wyniki jako komentarz).

Czego się dowiesz

Masz aplikację CRM do zarządzania potencjalnymi klientami z kodem vibe – agent AI zbudował dla Ciebie pełny stos: backend Express, bazę danych SQLite i frontend React. To działa. Następnie poprosiłeś(-aś) agenta o dodanie 2 nowych funkcji: funkcji wyszukiwania potencjalnych klientów oraz zbiorczego importowania i eksportowania ze statystykami administratora. Agent szybko dostarczył oba produkty. Kod działa, funkcje działają, a żądania scalenia są gotowe.

Ale jest pewien problem: nie Ty napisałeś(-aś) ten kod. Zostało przez Ciebie zatwierdzone. Skąd wiesz, że punkt końcowy wyszukiwania nie jest podatny na wstrzyknięcie kodu SQL? Skąd wiesz, że ścieżka administratora nie ma zakodowanego na stałe hasła? Nie musisz tego robić, a czytanie każdego wiersza kodu wygenerowanego przez AI niweczy przewagę szybkości, która skłoniła Cię do zastosowania vibe codingu.

W tym ćwiczeniu znajdziesz 2 sposoby rozwiązania tego problemu:

  • Przypadek 1. Interaktywna weryfikacja: sprawdź gałąź funkcji z lukami w zabezpieczeniach, użyj interfejsu Antigravity CLI z umiejętnościami agenta, aby sprawdzić różnice, rozwiązać problemy i utworzyć czyste żądanie scalenia.
  • Przypadek 2. Sprawdzanie automatyczne: skonfiguruj działanie GitHub oparte na Antigravity SDK, które automatycznie weryfikuje żądania pull, publikuje uporządkowane wyniki w postaci komentarzy i odpowiada na pytania programistów dotyczące weryfikacji.

8e05b6954f30ee3b.jpeg

Czego się nauczysz

  • Jak vibe coding może stwarzać zagrożenia dla bezpieczeństwa i dlaczego sprawdzanie automatyczne wykrywa to, co umyka ręcznej weryfikacji
  • Jak zainstalować i używać umiejętności agenta utrzymywanych przez społeczność, aby zapewnić Antigravity CLI zaawansowaną wiedzę z zakresu bezpieczeństwa i inspekcji kodu
  • Jak interaktywnie korzystać z interfejsu wiersza poleceń, aby sprawdzić różnice w gałęzi funkcji, naprawić luki w zabezpieczeniach i utworzyć czyste żądanie scalenia
  • Jak za pomocą pakietu Antigravity SDK utworzyć agenta do inspekcji kodu z dostępem tylko do odczytu, deklaratywnymi zasadami bezpieczeństwa i hakami cyklu życia
  • Jak wdrożyć agenta sprawdzającego jako działanie GitHub, które sprawdza żądania pull i publikuje wynik jako komentarz do żądania pull

Wymagania wstępne

  • konto Google Cloud;
  • konto GitHub,
  • Podstawowa znajomość terminala, kontroli wersji i CI/CD

2. Konfiguracja środowiska

W tym kroku rozwidlisz repozytorium aplikacji CRM do obsługi potencjalnych klientów, sklonujesz je w Cloud Shell, skonfigurujesz Antigravity CLI i przeprowadzisz uwierzytelnianie.

Utwórz rozwidlenie repozytorium

Potrzebujesz własnej kopii repozytorium, ponieważ będziesz przenosić zatwierdzenia i tworzyć żądania pull za pomocą GitHub Actions.

Otwórz to repozytorium

Następnie kliknij Fork (Rozwidlenie). Na stronie tworzenia forka odznacz pole wyboru „Skopiuj tylko gałąź main” – musisz uwzględnić w forku inne gałęzie funkcji (feature/lead-search i feature/bulk-operations).

3f996e391d2d5cf4.png7e4089174c2adb07.png

Otwieranie Cloud Shell

Otwórz Cloud Shell w przeglądarce. Cloud Shell udostępnia wstępnie skonfigurowane środowisko ze wszystkimi narzędziami potrzebnymi do wykonania tego ćwiczenia. Gdy pojawi się prośba o autoryzację, kliknij Autoryzuj.

Następnie kliknij „Widok” –> „Terminal”, aby otworzyć terminal.Interfejs powinien wyglądać podobnie do tego:

86307fac5da2f077.png

Będzie to nasz główny interfejs: IDE u góry, terminal u dołu.

Uwierzytelnianie w GitHub

Domyślnie Cloud Shell nie ma skonfigurowanych danych logowania do GitHub, ale ma już zainstalowany interfejs gh CLI. Skonfiguruj uwierzytelnianie, aby później móc przesyłać zmiany i tworzyć żądania scalenia:

gh auth login

303f60fa2e73b305.png

Zaznacz Github.com

97e55d4bb4a167af.pngWybierz HTTPS ( lub wybierz inny mechanizm, jeśli go znasz).

561493764dbe64ef.png

Następnie kliknij Y.

ed05929c1bcb731.png

Następnie kliknij Login with a web browser.

** **Poprosimy Cię o skopiowanie kodu jednorazowego i wpisanie go po otwarciu strony logowania w przeglądarce. Możesz Ctrl + Click kliknąć URL w terminalu, aby otworzyć URL https://github.com/login/device. Pojawi się prośba o wybranie konta, na które chcesz się zalogować, i wpisanie kodu.

915314584db6766d.png

Następnie wróć na stronę konsoli Cloud Shell. Zobaczysz dane wyjściowe terminala podobne do tych:

✓ 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

Oznacza to, że udało Ci się skonfigurować uwierzytelnianie konta GitHub w Cloud Shell.

Sklonuj rozwidlone repozytorium

Następnie sklonuj rozwidlone repozytorium. Zastąp <YOUR_GITHUB_USERNAME> swoją nazwą użytkownika 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

Weryfikowanie gałęzi funkcji

Następnie sprawdź, czy w repozytorium zdalnym są dostępne obie gałęzie funkcji z wcześniej utworzonymi lukami w zabezpieczeniach:

git branch -a | grep feature/

Powinny pojawić się te dane wyjściowe:

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

Weryfikowanie interfejsu Antigravity CLI

Następnie sprawdźmy, czy interfejs Antigravity CLI jest wstępnie zainstalowany w Cloud Shell. Sprawdź, czy jest dostępna:

agy --version

Powinna być widoczna wersja zainstalowanego interfejsu wiersza poleceń Antigravity, np. 1.0.13

Jeśli nie masz jeszcze uwierzytelnionego interfejsu Antigravity CLI, możesz przejść do tego ćwiczenia z programowania, aby dowiedzieć się więcej o procesie uwierzytelniania.

W tym momencie powinny być dostępne te elementy:

  • sklonowane rozwidlone repozytorium,
  • widoczne są obie gałęzie funkcji,
  • agy polecenie jest dostępne i uwierzytelnione;

3. Problem – luki w zabezpieczeniach ukryte w funkcjach opartych na wibracjach

Oto scenariusz: członek zespołu użył agenta AI, aby dodać do aplikacji CRM do zarządzania kontaktami do potencjalnych klientów 2 funkcje – wyszukiwanie kontaktów do potencjalnych klientów oraz operacje importowania i eksportowania zbiorczego. Obie funkcje działają. Oba zostały szybko wysłane bez sprawdzania zabezpieczeń. Przed scaleniem przejrzysz oba rozgałęzienia – jedno interaktywnie za pomocą interfejsu CLI, a drugie automatycznie za pomocą działania GitHub.

Sprawdź pierwszą gałąź funkcji

Sprawdź różnice na stronie feature/lead-search:

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

Ta gałąź dodaje punkt końcowy wyszukiwania. Przejrzyj różnice – powinny być widoczne problemy takie jak konkatenacja ciągów w zapytaniach SQL, brak weryfikacji danych wejściowych, logowanie debugowania, które ujawnia szczegóły zapytania, oraz surowe komunikaty o błędach widoczne dla klienta.

+  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" });
+    }
...

Sprawdź drugą gałąź funkcji

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

Ta gałąź dodaje punkty końcowe importu i eksportu zbiorczego oraz panel statystyk administratora. Luki w zabezpieczeniach obejmują zakodowane na stałe dane logowania administratora, nieuwierzytelnione punkty końcowe administratora, brak weryfikacji danych wejściowych podczas importu zbiorczego oraz ryzyko [ataku typu] path traversal w obsłudze nazw plików eksportu.

...
+  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" });
+    }
...

Obie gałęzie dodają funkcjonalne funkcje. Oba mają problemy z bezpieczeństwem. Pytanie brzmi, jak je wykryć – ręcznie za pomocą interfejsu wiersza poleceń (przypadek 1) czy automatycznie za pomocą działania GitHub (przypadek 2).

4. Przypadek 1. Interaktywna weryfikacja za pomocą interfejsu wiersza poleceń Antigravity

Interaktywne sprawdzanie interfejsu CLI jest najbardziej przydatne bezpośrednio po sesji vibe codingu, podczas sprawdzania napisanego kodu lub sprawdzania żądania pull od członków zespołu. Jeśli mówimy o kodowaniu na podstawie nastroju, agent AI szybko wygenerował kod funkcji, ale możesz nie w pełni rozumieć każdego wiersza, który utworzył. Agent może być zoptymalizowany pod kątem funkcjonalności, a niekoniecznie bezpieczeństwa, w zależności od konfiguracji kontekstu podczas tworzenia funkcji.

W tym scenariuszu mamy kody z lukami w zabezpieczeniach i użyjemy Antigravity CLI z umiejętnościami weryfikacji kodu, aby interaktywnie sprawdzić kod. Ten wzorzec, w którym agent sprawdza agenta, wykrywa luki w zabezpieczeniach, które mogą się pojawić, gdy rola dewelopera zmieni się z pisania kodu na zatwierdzanie kodu wygenerowanego przez AI. Dotyczy to również sprawdzania własnego kodu napisanego ręcznie lub gałęzi współpracownika przed przejściem przez CI. Masz kontrolę nad rozmową: poproś agenta o skupienie się na konkretnych plikach, dokładniejsze zbadanie problemu lub natychmiastowe zastosowanie poprawek.

Bez umiejętności agenta interfejs Antigravity CLI nadal może sprawdzać kod, ale opiera się na ogólnej wiedzy zdobytej podczas trenowania, co może powodować pomijanie wzorców specyficznych dla danej domeny lub stosowanie niespójnych kryteriów sprawdzania w różnych sesjach. Umiejętności agenta zapewniają mu uporządkowany przewodnik: 5-stopniową ocenę jakości i etykietowanie ważności w celu ustalenia priorytetów. Sprawdzanie staje się powtarzalne i dokładne niezależnie od tego, jak sformułujesz prompta.

W tym kroku użyjesz interfejsu wiersza poleceń Antigravity z umiejętnościami agenta, aby sprawdzić gałąź feature/lead-search, naprawić luki w zabezpieczeniach i utworzyć czyste żądanie scalenia.

Wyewidencjonuj gałąź funkcji

Najpierw przełączmy się na gałąź Case 1:

git checkout feature/lead-search

Następnie ulepszmy Antigravity CLI za pomocą umiejętności agenta, aby przeprowadzić weryfikację.

Czym są umiejętności agenta

Umiejętności to deklaratywne pliki Markdown, które zapewniają agentowi specjalistyczną wiedzę. Po zainstalowaniu stają się poleceniami po ukośniku (np. /code-review-and-quality). Można je traktować jako przekazanie agentowi do zwykłych obciążeń zasad bezpieczeństwa starszego inżyniera.

Umiejętności można przenosić między agentami (Antigravity, Claude Code, Cursor itp.) i udostępniać za pomocą Git. W przypadku interfejsu Antigravity CLI umiejętności obszaru roboczego (projektu lub lokalnego) znajdują się w .agents/skills/ w katalogu głównym projektu. Umiejętności globalne są dostępne w ~/.gemini/config/skills/. Więcej informacji znajdziesz w tej dokumentacji

Aby zademonstrować możliwości umiejętności agenta, w tym ćwiczeniu wykorzystamy umiejętność inspekcji kodu z repozytorium addyosmani/agent-skills:

  • code-review-and-quality – pięcioosiowa ocena (poprawność, czytelność, architektura, bezpieczeństwo, wydajność) z oznaczeniem ważności.

Zainstaluj umiejętność agenta weryfikacji kodu

Korzystając z polecenia poniżej, umiejętność zostanie domyślnie zainstalowana w .agents/skills/ w bieżącym katalogu roboczym – instalacja na poziomie obszaru roboczego. Oznacza to, że stają się one częścią repozytorium i można je zatwierdzać razem z kodem, dzięki czemu każdy programista (i potok CI) w projekcie automatycznie uzyskuje te same umiejętności sprawdzania.

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

Oto szczegółowa umiejętność, którą można sprawdzić w pliku .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.

Najważniejsze funkcje:

  • Sprawdzanie pod kątem 5 aspektów: poprawności, czytelności, architektury, bezpieczeństwa i wydajności.
  • Oznacza wyniki według poziomu ważności, aby umożliwić Ci najpierw rozwiązanie krytycznych problemów.
  • Stosuje standard zatwierdzania: „zatwierdź, jeśli z pewnością poprawia ogólny stan kodu, nawet jeśli nie jest idealny”.

Teraz możemy przejść do wykonania. Sprawdźmy umiejętność w interfejsie Antigravity CLI

Uruchomienie AGY i weryfikacja umiejętności

Uruchamianie interfejsu Antigravity CLI

agy --dangerously-skip-permissions

Następnie uruchom to polecenie:

/skills

Powinny pojawić się 2 umiejętności, jak pokazano poniżej w sekcji Workspace umiejętności.

490090ce9f955d1c.png

Przeprowadź weryfikację kodu różnic w funkcji

Wywołaj umiejętność związaną z bezpieczeństwem i poproś ją o sprawdzenie gałęzi. Wpisz ten prompt:

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.

Agent wykrywa odpowiednią umiejętność code-review-and-quality i automatycznie ją aktywuje. Odczytuje różnice, identyfikuje luki w zabezpieczeniach i zapisuje wyniki wraz z proponowanym planem naprawy w code_review.md.

86c054f06c122df8.png

Po zakończeniu skanowania w katalogu roboczym powinien pojawić się plik code_review.md, który możesz sprawdzić w edytorze.

bcd382689b0a95fa.png2b6892e261c046b2.png

Sprawdź każde wykryte naruszenie i proponowaną poprawkę. Gdy plan będzie gotowy, poproś agenta o jego zastosowanie:

Apply the proposed fixes from code_review.md

Agent odczytuje plan i stosuje każdą zaplanowaną poprawkę do plików źródłowych.

cc1e5bb5ad9533c7.png

Teraz, jeśli chcesz, możesz sprawdzić, czy aplikacja działa prawidłowo po naprawieniu błędu, instalując zależności i uruchamiając ją.

npm install
npm run dev

Aplikacja powinna działać prawidłowo. Jeśli nie, możesz powtórzyć proces i poprosić interfejs Antigravity CLI o naprawienie problemu.

Zatwierdzanie i tworzenie żądania zmiany

Jeśli chcesz, możesz teraz przenieść zmiany do własnego repozytorium. Zanim przejdziesz do następnego przypadku, zatwierdź zmiany w bieżącej gałęzi.

Najpierw musimy skonfigurować Twoją tożsamość Git (zastąp ją własnym imieniem i adresem e-mail), jeśli jeszcze tego nie zrobiono:

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

Następnie zatwierdź zmiany.

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

Interfejsu wiersza poleceń Antigravity używasz już jako interaktywnego recenzenta. Dzięki tym umiejętnościom ma on ustrukturyzowaną metodologię – pięcioosiową inspekcję kodu. Ta funkcja działa, gdy deweloper sprawdza wygenerowany przez AI kod, swój własny lub kod przesłany przez członka zespołu. W następnej sekcji zautomatyzujemy cały ten proces, aby w repozytorium kodu stworzyć skalowalny proces automatyczny. Jako przykładu użyjemy GitHub.

5. Przypadek 2. Automatyczna weryfikacja za pomocą pakietu Antigravity SDK – część 1 ( tworzenie agenta)

W tym kroku utworzysz agenta do sprawdzania automatycznego za pomocą pakietu Antigravity SDK, wdrożysz go jako działanie GitHub i przetestujesz na drugiej gałęzi funkcji. Agent sprawdza żądania pull na żądanie i publikuje wyniki jako komentarze do żądań pull.

Dlaczego automatyczne sprawdzanie

Interaktywne sprawdzanie w interfejsie wiersza poleceń (przypadek 1) działa, gdy deweloper aktywnie sprawdza. Zespoły potrzebują weryfikacji, która jest przeprowadzana automatycznie w przypadku każdego żądania scalenia, aby wykrywać problemy zgłaszane przez dowolnego współpracownika, za pomocą dowolnego narzędzia i w dowolnym momencie. Pakiet Antigravity SDK (google-antigravity) udostępnia ten sam środowisko wykonawcze agenta co interfejs CLI w postaci biblioteki Pythona. Zasady i punkty zaczepienia są konfigurowane w kodzie.

Działania na GitHubie to wbudowana platforma ciągłej integracji i ciągłego dostarczania (CI/CD) GitHub. Uruchamia przepływy pracy – automatyczne skrypty zdefiniowane w YAML – w odpowiedzi na zdarzenia w repozytorium, takie jak otwarcie żądania scalenia, zatwierdzenie zmian lub opublikowanie komentarza. Przepływy pracy są uruchamiane na maszynach wirtualnych hostowanych na GitHubie i mają dostęp do kodu repozytorium. W tym przypadku używasz działania GitHub, aby uruchamiać agenta sprawdzającego zabezpieczenia za każdym razem, gdy tworzone jest żądanie pull.

Oto jak działa proces sprawdzania automatycznego:

393f76210e797217.png

Pakiet Antigravity SDK ( google-antigravity) udostępnia ten sam środowisko wykonawcze agenta co interfejs CLI w postaci biblioteki Pythona. Piszesz skrypt w Pythonie, który konfiguruje agenta za pomocą zasad i haków, uruchamiasz go w ramach działania GitHub i publikujesz wyniki jako komentarz do żądania pull.

Uzyskiwanie klucza interfejsu Gemini API

Zanim zaczniemy, musimy uzyskać klucz interfejsu Gemini API, który będzie używany przez pakiet Antigravity SDK. Otwórz klucz interfejsu API Google AI Studio i utwórz klucz interfejsu API. W razie potrzeby możesz go skopiować.

57b306d2292c60bf.png

Ten klucz będzie używany podczas lokalnego uruchamiania agenta sprawdzającego i później jako tajny klucz GitHub Actions.

Część A. Tworzenie agenta do sprawdzania

W przypadku scenariusza 2 zmień bieżący katalog roboczy na gałąź feature/bulk-operations:

git checkout feature/bulk-operations

Jest to druga gałąź funkcji w scenariuszu – dodaje do aplikacji CRM punkty końcowe importu i eksportu zbiorczego oraz panel statystyk administratora.

Konfigurowanie projektu w Pythonie

Pakiet Antigravity SDK jest obecnie dostępny tylko w Pythonie, dlatego do jego opracowania potrzebne będzie środowisko Python. Do zarządzania projektem w Pythonie użyjemy uv. uv to szybki menedżer pakietów i projektów Pythona napisany w języku Rust ( dokumentacja). W tym ćwiczeniu używamy go ze względu na szybkość i prostotę. Jeśli w tym samouczku korzystasz z Cloud Shell, jest on już zainstalowany na instancji. Jeśli chcesz zainstalować go na swoim komputerze lokalnym, zapoznaj się z tym samouczkiem.

Zainicjuj projekt w Pythonie dla agenta sprawdzającego za pomocą polecenia uv:

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

Spowoduje to utworzenie nowego katalogu code_review_agent, który będzie zawierać niezbędne pliki agenta do inspekcji kodu.

Instalowanie umiejętności sprawdzania

Osoba sprawdzająca musi mieć te same umiejętności w zakresie bezpieczeństwa i inspekcji kodu, co w przypadku 1. Zainstaluj je w code_review_agent/skills/, aby agent SDK wczytywał je w czasie działania:

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

Tworzenie agenta sprawdzającego

Teraz utwórzmy code_review_agent/review_agent.py . Uruchom to polecenie:

cloudshell edit code_review_agent/review_agent.py

Następnie skopiuj do pliku tę treść:

#!/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))

Przejrzyj kluczowe decyzje projektowe dotyczące tego agenta:

  • Zasady domyślnego odrzucania: policy.deny_all() blokuje wszystko, a następnie zezwala tylko na narzędzia do odczytu plików i run_command (w przypadku Gita).
  • Wymuszanie na 2 poziomach: zasady ograniczają dostęp na poziomie platformy, a punkt zaczepienia enforce_safe_tools zapewnia drugą warstwę, umożliwiając przekazywanie tylko poleceń git przez run_command .
  • Określanie zakresu różnic w Git: agent uruchamia polecenie git diff main...HEAD, aby sprawdzić tylko zmieniony kod, a nie całą bazę kodu.
  • Dane wyjściowe w formacie strukturalnym z wersją zapasową: response_schema=ReviewResult wymusza strukturę JSON za pomocą narzędzia do kończenia w SDK. Jeśli analiza się nie powiedzie, łańcuch zastępowania spróbuje przeanalizować text() jako JSON, a następnie zwróci zwykły tekst.
  • Rezerwowe uwierzytelnianie: korzysta z GEMINI_API_KEY, jeśli jest dostępny, w przeciwnym razie wraca do Vertex AI za pomocą domyślnych danych logowania aplikacji.
  • Dane wyjściowe pliku: zapisuje sformatowane wyniki w formacie Markdown w code_review.md – działanie GitHub odczytuje ten plik i publikuje go później jako komentarz do żądania pull.

Testowanie agenta sprawdzającego

Testuj z katalogu głównego projektu. SDK odczyta GEMINI_API_KEY ze środowiska, więc umieśćmy klucz w środowisku.

export GEMINI_API_KEY=YOUR_API_KEY

Następnie uruchom to polecenie, aby uruchomić go lokalnie:

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

Podczas działania wyświetla dane wyjściowe konsoli z informacjami o używanych narzędziach. Możesz to zauważyć, korzystając z umiejętności agentów security-and-hardening i 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']
...

Agent uruchamia git diff main...HEAD, sprawdza tylko zmieniony kod, zapisuje sformatowane wyniki w code_review.md i wyświetla w konsoli uporządkowany kod JSON. Możesz sprawdzić napisany code_review.md w edytorze, jak pokazano poniżej.

e8f97c737aaf934b.png

Lokalnie już działa, więc przejdźmy do następnej części. Tworzenie konfiguracji działania GitHub

6. Przypadek 2. Automatyczna weryfikacja za pomocą pakietu Antigravity SDK – część 2 ( konfigurowanie działań GitHub)

Zanim zaczniemy, usuńmy wcześniej wygenerowany plik code_review.md, jeśli istnieje.

rm -f code_review.md

Teraz musimy utworzyć plik konfiguracji YAML działania GitHub.

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

Następnie dodaj do pliku te wiersze:

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
            });

Przepływ pracy zostanie uruchomiony automatycznie po otwarciu lub zaktualizowaniu żądania scalenia. Sprawdza gałąź PR z pełną historią Git (potrzebną w przypadku git diff main...HEAD), uruchamia agenta sprawdzającego, który zapisuje wyniki w code_review.md, i publikuje zawartość pliku jako komentarz do PR.

Teraz zatwierdźmy wszystkie zmiany i prześlijmy je do zdalnego repozytorium GitHub. Możemy już przetestować tę integrację.

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

7. Przypadek 2. Automatyczne sprawdzanie za pomocą pakietu Antigravity SDK – część 3 (testowanie automatycznego sprawdzania kodu)

Teraz przejdź do rozwidlonego repozytorium https://github.com/<YOUR_GITHUB_USERNAME>/leads-crm-app-demo i kliknij Settings.

15e07c4d8c425e33.png

Następnie w panelu po lewej stronie znajdź Secrets and variables i kliknij Actions.

67d1b299fcd242b4.png

Następnie kliknij New repository secret, aby skonfigurować klucz tajny GEMINI_API_KEY.

b8c270070e1613c9.png

Następnie wybierz Pull Request i utwórz nową prośbę o scalenie z gałęzi feature/bulk_operations do gałęzi main własnego repozytorium.

e37f57b56a143d9c.pngda9b78d57c0aec4e.png

Po utworzeniu żądania pull zostaną uruchomione działania GitHub, które możesz sprawdzić w menu Checks lub w pobliżu przycisku Merge pull request.

b9b811c4430f7702.png

Możesz kliknąć uruchomione działania, aby zobaczyć szczegóły. Po zakończeniu działania opublikują wyniki sprawdzania jako komentarz do żądania scalenia, jak pokazano poniżej.

544d4d820019e58.png

8. Podsumowanie

Gratulacje!

Utworzono 2 kompletne przepływy pracy weryfikacji kodu, które umożliwiają wykrywanie luk w zabezpieczeniach w funkcjach oznaczonych kodem wibracyjnym:

  • Przypadek 1 (interaktywny): interfejs wiersza poleceń Antigravity z umiejętnościami agenta przeanalizował różnice w gałęzi funkcji, wykrył wstrzyknięcie kodu SQL i inne luki w zabezpieczeniach, naprawił je zgodnie ze wzorcami OWASP i utworzył czyste żądanie scalenia.
  • Przypadek 2 (zautomatyzowany): pakiet SDK Antigravity obsługiwał działanie GitHub, które automatycznie sprawdzało każde żądanie pull i publikowało strukturalne wyniki dotyczące bezpieczeństwa w postaci komentarzy do żądania pull.

Czego się nauczysz

  • Jak vibe coding stwarza zagrożenia dla bezpieczeństwa i dlaczego sprawdzanie automatyczne wykrywa to, co umyka weryfikacji ręcznej
  • Jak zainstalować i używać umiejętności agenta, aby zapewnić interfejsowi wiersza poleceń Antigravity strukturalną wiedzę z zakresu bezpieczeństwa
  • Jak interaktywnie sprawdzić różnice w gałęzi funkcji, rozwiązać problemy i utworzyć przejrzyste żądanie scalenia
  • Tworzenie agenta do odczytu opinii za pomocą pakietu Antigravity SDK z użyciem zasad domyślnego odrzucania i punktów zaczepienia cyklu życia
  • Jak wdrożyć potok sprawdzania automatycznego jako działanie GitHub z obsługą interaktywnego uzupełniania

Czyszczenie danych

Zamknij zgłoszenia

Otwórz każde żądanie pull w swoim rozwidleniu w GitHubie i kliknij Close pull request (Zamknij żądanie pull). Nie scalaj feature/bulk-operations PR – nadal zawiera on niezałatany kod podatny na ataki.

Usuń rozwidlone repozytorium (opcjonalnie)

Jeśli nie potrzebujesz już forka, otwórz go w GitHubie: Settings (Ustawienia) –> przewiń do Danger Zone (Strefa zagrożenia) –> Delete this repository (Usuń to repozytorium).

Co dalej