The full guide for Gemini Code Assist can be found on our documentation page, here are some quick tips.

Invoking Gemini

You can request assistance from Gemini at any point in your pull request via creating an issue comment (i.e. comment on the pull request page) using either /gemini <command> or @gemini-code-assist <command>. Below is a summary of the supported commands.

Customization

To customize Gemini Code Assist for GitHub experience, repository maintainers can create a configuration file and/or provide a custom code review style guide (such as PEP-8 for Python) by creating and adding files to a .gemini/ folder in the base of the repository. Detailed instructions can be found here.

Limitations & Feedback

Gemini Code Assist may make mistakes. Please leave feedback on any instances where its feedback is incorrect or counter productive. You can react with 👍 and 👎 on @gemini-code-assist comments. If you're interested in giving your feedback about your experience with Gemini Code Assist for Github and other Google products, sign up here.

You can also get AI-powered code generation, chat, as well as code reviews directly in the IDE at no cost with the Gemini Code Assist IDE Extension.

cmd/httpcache.go (3)

40-44: Tighten directory permissions to 0o700 to minimize metadata exposure.

Files are written with 0o600, but the directory is 0o750, which allows group members to list hashed filenames. While filenames are hashes, listing may still leak request cadence. Prefer 0o700 for the cache dir. On Windows, mode is mostly ignored, so this remains safe and portable.

Apply this diff to both mkdir calls:

- if err := os.MkdirAll(cacheDir, 0o750); err != nil {
+ if err := os.MkdirAll(cacheDir, 0o700); err != nil {

Also applies to: 78-82

---

100-102: Use temp-file + rename for atomic writes and crash-safety.

An unexpected crash during os.WriteFile can leave a truncated file that future readers will treat as a corrupted cache entry. Writing to a temp file in the same directory and Rename-ing it into place avoids partial writes.

- if err := os.WriteFile(cacheFile(url), b, 0o600); err != nil {
-   log.Printf("httpcache: write cache file for %s: %v", url, err)
- }
+ cf := cacheFile(url)
+ tmp := cf + ".tmp"
+ if err := os.WriteFile(tmp, b, 0o600); err != nil {
+   log.Printf("httpcache: write temp cache file for %s: %v", url, err)
+   return
+ }
+ if err := os.Rename(tmp, cf); err != nil {
+   // Best effort fallback for platforms where rename may not replace.
+   _ = os.Remove(cf) //nolint:errcheck
+   if err2 := os.Rename(tmp, cf); err2 != nil {
+     log.Printf("httpcache: replace cache file for %s: %v", url, err2)
+   }
+ }

---

21-27: Align in-memory cache semantics with disk TTL to avoid indefinite staleness.

The in-memory responseCache never expires, so a long-lived process can serve stale data far beyond cacheTTL, even though file cache enforces expiry. Consider storing cacheEntry in-memory and enforcing TTL consistently.

@@
 var (
   cacheMu       sync.RWMutex
-  responseCache = make(map[string][]byte)
+  responseCache = make(map[string]cacheEntry)
@@
- cacheMu.RLock()
- if b, ok := responseCache[url]; ok {
-   cacheMu.RUnlock()
-   return b, http.StatusOK, nil
- }
- cacheMu.RUnlock()
+ cacheMu.RLock()
+ if e, ok := responseCache[url]; ok {
+   if time.Now().Before(e.Expiry) {
+     cacheMu.RUnlock()
+     return e.Body, http.StatusOK, nil
+   }
+ }
+ cacheMu.RUnlock()
@@
- if b, ok := responseCache[url]; ok {
-   return b, http.StatusOK, nil
- }
+ if e, ok := responseCache[url]; ok {
+   if time.Now().Before(e.Expiry) {
+     return e.Body, http.StatusOK, nil
+   }
+   delete(responseCache, url)
+ }
@@
- if res.StatusCode == http.StatusOK {
-   responseCache[url] = body
-   writeToFile(url, body)
- }
+ if res.StatusCode == http.StatusOK {
+   responseCache[url] = cacheEntry{Expiry: time.Now().Add(cacheTTL), Body: body}
+   writeToFile(url, body)
+ }
@@
- responseCache = make(map[string][]byte)
+ responseCache = make(map[string]cacheEntry)

If you’d prefer to keep the fast path, you can also add a very small TTL (e.g., 30–60s) for memory while keeping 5 min on disk.

Also applies to: 108-114, 118-121, 151-154, 161-164

cmd/httpcache_test.go (2)

10-16: Isolate cacheDir per test using t.TempDir to avoid cross-test interference.

Because cacheDir is a package-level var, parallel or future tests can step on each other. Point the cache to a unique temp dir and restore afterward.

 func Test_HTTPCache_ReadWrite(t *testing.T) {
-  clearHTTPCache()
+  // Isolate cache directory for this test
+  oldDir := cacheDir
+  cacheDir = t.TempDir()
+  t.Cleanup(func() { cacheDir = oldDir })
+  clearHTTPCache()

---

9-23: Optional: add an expiry subtest for read path.

If you want to exercise the expiry logic end-to-end, we can temporarily shrink cacheTTL in the test and verify that a read after expiry returns ok == false. Happy to add this as a follow-up.

Configuration used: CodeRabbit UI

Review profile: CHILL

Plan: Pro

💡 Knowledge Base configuration:

• MCP integration is disabled by default for public repositories
• Jira integration is disabled by default for public repositories
• Linear integration is disabled by default for public repositories

You can enable these sources in your CodeRabbit configuration.