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/internal/migrations/lists.go (4)

155-161: Restore cmd output with defer to avoid leaking writers on panic.

If a migration panics, the writer won’t be restored. Use defer right after SetOut.

Apply this diff:

-                var buf bytes.Buffer
-                origOut := cmd.OutOrStdout()
-                cmd.SetOut(io.MultiWriter(origOut, &buf))
-                err := fn(cmd, cwd, curr, target)
-                cmd.SetOut(origOut)
+                var buf bytes.Buffer
+                origOut := cmd.OutOrStdout()
+                cmd.SetOut(io.MultiWriter(origOut, &buf))
+                defer cmd.SetOut(origOut)
+                err := fn(cmd, cwd, curr, target)

---

104-117: Regex vs. glob detection can surprise users; consider clarifying or tightening semantics.

Current behavior:

• Try glob (filepath.Match). If not matched and pattern “looks like regex” (per isRegexPattern), try regex; otherwise return false.
• Regex is a substring match by default (re.MatchString), not a full-string match.

Risks:

• Patterns like fnF.* won’t be recognized as regex (no characters from isRegexPattern), thus won’t match as users expect.
• Patterns containing ? are treated as regex-worthy; after a glob miss they’ll be interpreted as regex, changing semantics.

Options:

• Anchor regex matches by default (^...$) to reduce accidental substring matches.
• Expand detection to treat common regex constructs (.*) as regex, or introduce an explicit re: prefix to force regex interpretation.
• At minimum, document these semantics in the CLI/docs.

I recommend anchoring and recognizing .* explicitly; add tests accordingly.

Proposed local change (illustrative):

- if re, err := regexp.Compile(pattern); err == nil {
-   return re.MatchString(name)
- }
+ if re, err := regexp.Compile(pattern); err == nil {
+   return re.MatchString(name)
+ }

Outside this hunk, either:

• Anchor only when treating as regex:
  re, _ := regexp.Compile("^" + pattern + "$")
• Or add a rule in isRegexPattern to also return true when strings.Contains(pattern, ".*").

---

119-121: Regex heuristic misses common cases like .*; either broaden detection or document.

isRegexPattern ignores . and *. A typical regex such as Migrate.*Config won’t be detected as regex and will be treated as a literal dot + glob star pattern. Consider:

• Return true when pattern contains .*, or
• Keep the heuristic but document that regex must include one of ^ $ [ ] ( ) | + ? \ to be recognized.

Add targeted tests to lock this in.

---

95-102: Tiny nit: early return micro-optimization.

You can check for empty patterns first or iterate with a range over indexless slice; style is fine—no change required unless you’re micro-tuning.

cmd/internal/migrations/filter_test.go (1)

46-54: Regex test looks good; consider adding a case for .* without anchors.

Given current detection, fnF.* isn’t treated as regex. Add a test to pin intended behavior (glob-only or regex fallback) and avoid future surprises.

docs/guide/migrate.md (1)

26-27: Clarify pattern semantics and add examples for include/exclude.

As implemented, a pattern is treated as:

• Glob by default.
• Regex only if it includes at least one of ^ $ [ ] ( ) | + ? \.

Add a brief note and examples to reduce confusion, and show shell-quoting.

Proposed addition (outside this hunk):

### Include/Exclude examples

- Only run migrations starting with `MigrateGo` (glob):
  fiber migrate --include 'MigrateGo*'

- Skip all session-related migrations (regex):
  fiber migrate --exclude '^(?:MigrateSession.*)$'

Notes:
- Patterns are treated as globs unless they contain regex metacharacters like ^ $ [ ] ( ) | + ? \.
- Regex matches are not anchored unless you use ^ and $, so add them when you intend a full-name match.
- Quote patterns to prevent your shell from expanding them.

cmd/migrate.go (1)

44-46: Trim whitespace and ignore empty entries from StringSlice flags.

Users often write --include "A, B". Cobra does not trim individual items. Sanitize before using.

Apply this diff to sanitize in-place within RunE:

 cmd.RunE = func(cmd *cobra.Command, _ []string) error {
@@
-        return migrateRunE(cmd, MigrateOptions{
+        // sanitize patterns
+        include = sanitizePatterns(include)
+        exclude = sanitizePatterns(exclude)
+
+        return migrateRunE(cmd, MigrateOptions{

Add this helper (outside the changed hunk):

func sanitizePatterns(in []string) []string {
    out := make([]string, 0, len(in))
    for _, s := range in {
        s = strings.TrimSpace(s)
        if s != "" {
            out = append(out, s)
        }
    }
    return out
}

Optional: tweak help to hint at trimming:

- cmd.Flags().StringSliceVar(&include, "include", nil, "Comma-separated list of migrations to include. Supports glob and regex patterns")
+ cmd.Flags().StringSliceVar(&include, "include", nil, "Comma-separated list (whitespace trimmed) of migrations to include. Supports glob and regex patterns")
- cmd.Flags().StringSliceVar(&exclude, "exclude", nil, "Comma-separated list of migrations to exclude. Supports glob and regex patterns")
+ cmd.Flags().StringSliceVar(&exclude, "exclude", nil, "Comma-separated list (whitespace trimmed) of migrations to exclude. Supports glob and regex patterns")

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.

cmd/internal/helpers.go (1)

121-134: Remove regex-heuristic; always try regex after glob.

The isRegexPattern heuristic is incomplete and can misclassify valid regexes (e.g., v3.Migrate.*). Always attempt regex if glob didn’t match.

-func matchPattern(name, pattern string) bool {
-	if ok, err := filepath.Match(pattern, name); err == nil {
-		if ok {
-			return true
-		}
-		if !isRegexPattern(pattern) {
-			return false
-		}
-	}
-	if re, err := regexp.Compile(pattern); err == nil {
-		return re.MatchString(name)
-	}
-	return name == pattern
-}
-
-func isRegexPattern(p string) bool {
-	return strings.ContainsAny(p, "^$[]()|+?\\")
-}
+func matchPattern(name, pattern string) bool {
+	if ok, err := filepath.Match(pattern, name); err == nil && ok {
+		return true
+	}
+	if re, err := regexp.Compile(pattern); err == nil {
+		return re.MatchString(name)
+	}
+	return name == pattern
+}

Also applies to: 136-138

cmd/internal/helpers.go (2)

37-41: Global filter state risks tight coupling; prefer scoped configuration.

Consider passing include/exclude via parameters or a context/options object to ChangeFileContent to avoid global mutable state. This will improve testability and concurrency safety if multiple migrations run in parallel.

---

43-49: Defensively copy slices to prevent external mutation/data races.

Callers might mutate the provided slices after SetFileFilters returns. Copy the slices under the lock.

 func SetFileFilters(include, exclude []string) {
 	fileFilterMu.Lock()
-	fileIncludePatterns = include
-	fileExcludePatterns = exclude
+	if include != nil {
+		fileIncludePatterns = append([]string(nil), include...)
+	} else {
+		fileIncludePatterns = nil
+	}
+	if exclude != nil {
+		fileExcludePatterns = append([]string(nil), exclude...)
+	} else {
+		fileExcludePatterns = nil
+	}
 	fileFilterMu.Unlock()
 }

cmd/internal/migrations/file_filter_test.go (1)

39-53: Great cases; add precedence and output assertions.

• Add a case where both include and exclude are set to assert exclude wins.
• Assert cmd output contains the expected “replaceFoo” marker when a change occurs.

 t.Run("include glob", func(t *testing.T) {
@@
-    require.NoError(t, migrations.DoMigration(cmd, dir, curr, target, true, false, []string{"*foo.go"}, nil))
+    require.NoError(t, migrations.DoMigration(cmd, dir, curr, target, true, false, []string{"*foo.go"}, nil))
+    assert.Contains(t, buf.String(), "replaceFoo")
@@
 })
 
 t.Run("exclude regex", func(t *testing.T) {
@@
-    require.NoError(t, migrations.DoMigration(cmd, dir, curr, target, true, false, nil, []string{"^bar\\.go$"}))
+    require.NoError(t, migrations.DoMigration(cmd, dir, curr, target, true, false, nil, []string{"^bar\\.go$"}))
+    assert.Contains(t, buf.String(), "replaceFoo")
@@
 })
+
+t.Run("include+exclude precedence (exclude wins)", func(t *testing.T) {
+    dir := t.TempDir()
+    require.NoError(t, os.WriteFile(filepath.Join(dir, "foo.go"), []byte("package main\nvar foo = 1\n"), 0o600))
+    require.NoError(t, os.WriteFile(filepath.Join(dir, "bar.go"), []byte("package main\nvar foo = 1\n"), 0o600))
+    var buf bytes.Buffer
+    cmd := &cobra.Command{}
+    cmd.SetOut(&buf)
+    // Include all *.go but exclude foo.go specifically
+    require.NoError(t, migrations.DoMigration(cmd, dir, curr, target, true, false, []string{"*.go"}, []string{"^foo\\.go$"}))
+    b, err := os.ReadFile(filepath.Join(dir, "foo.go"))
+    require.NoError(t, err)
+    assert.Contains(t, string(b), "var foo = 1") // excluded
+    b, err = os.ReadFile(filepath.Join(dir, "bar.go"))
+    require.NoError(t, err)
+    assert.Contains(t, string(b), "var bar = 1") // included
+    assert.Contains(t, buf.String(), "replaceFoo")
+})

Also applies to: 55-69

cmd/internal/migrations/lists.go (1)

95-97: Avoid reliance on global mutable state for filters.

If DoMigration could ever run concurrently, the global filter toggling becomes a contention point. Consider threading include/exclude into ChangeFileContent via an options parameter to eliminate globals.

cmd/migrate.go (1)

44-45: Tighten UX/help text; mention repeated flags usage.

Cobra’s StringSlice supports comma-separated and repeated flags. Consider clarifying and adding a quick example.

-cmd.Flags().StringSliceVar(&includeFiles, "include", nil, "Comma-separated list of files to include. Supports glob and regex patterns")
-cmd.Flags().StringSliceVar(&excludeFiles, "exclude", nil, "Comma-separated list of files to exclude. Supports glob and regex patterns")
+cmd.Flags().StringSliceVar(&includeFiles, "include", nil, "List of files to include (repeat flag or comma-separated). Supports glob and regex patterns, matched against cwd-relative paths")
+cmd.Flags().StringSliceVar(&excludeFiles, "exclude", nil, "List of files to exclude (repeat flag or comma-separated). Supports glob and regex patterns, matched against cwd-relative paths")

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.