Merge pull request #2991 from carapace-sh/jj-updates-v0.34.0

rsteube · web-flow · commit c1c96c468c32 · 2025-10-02T21:34:51.000+02:00
jj: updates from v0.34.0
diff --git a/completers/common/jj_completer/cmd/absorb.go b/completers/common/jj_completer/cmd/absorb.go
@@ -18,7 +18,7 @@ func init() {
 	absorbCmd.Flags().StringP("from", "f", "@", "Source revision to absorb from")
 	absorbCmd.Flags().BoolP("help", "h", false, "Print help (see more with '--help')")
 	absorbCmd.Flags().StringSliceP("into", "t", []string{"mutable()"}, "Destination revisions to absorb into")
-	absorbCmd.Flags().StringSlice("to", []string{"mutable()"}, "Alias for --into")
+	absorbCmd.Flags().StringSlice("to", []string{"mutable()"}, "Destination revisions to absorb into")
 	rootCmd.AddCommand(absorbCmd)
 
 	absorbCmd.MarkFlagsMutuallyExclusive("into", "to")
diff --git a/completers/common/jj_completer/cmd/bisect.go b/completers/common/jj_completer/cmd/bisect.go
@@ -0,0 +1,19 @@
+package cmd
+
+import (
+	"github.com/carapace-sh/carapace"
+	"github.com/spf13/cobra"
+)
+
+var bisectCmd = &cobra.Command{
+	Use:   "bisect",
+	Short: "Find a bad revision by bisection",
+	Run:   func(cmd *cobra.Command, args []string) {},
+}
+
+func init() {
+	carapace.Gen(bisectCmd).Standalone()
+
+	bisectCmd.Flags().BoolP("help", "h", false, "Print help (see more with '--help')")
+	rootCmd.AddCommand(bisectCmd)
+}
diff --git a/completers/common/jj_completer/cmd/bisect_run.go b/completers/common/jj_completer/cmd/bisect_run.go
@@ -0,0 +1,31 @@
+package cmd
+
+import (
+	"github.com/carapace-sh/carapace"
+	"github.com/carapace-sh/carapace-bin/pkg/actions/tools/jj"
+	"github.com/carapace-sh/carapace-bridge/pkg/actions/bridge"
+	"github.com/spf13/cobra"
+)
+
+var bisect_runCmd = &cobra.Command{
+	Use:   "run",
+	Short: "Run a given command to find the first bad revision",
+	Run:   func(cmd *cobra.Command, args []string) {},
+}
+
+func init() {
+	carapace.Gen(bisect_runCmd).Standalone()
+
+	bisect_runCmd.Flags().String("command", "", "Command to run to determine whether the bug is present")
+	bisect_runCmd.Flags().Bool("find-good", false, "Whether to find the first good revision instead")
+	bisect_runCmd.Flags().BoolP("help", "h", false, "Print help (see more with '--help')")
+	bisect_runCmd.Flags().StringSliceP("range", "r", nil, "Range of revisions to bisect")
+	bisect_runCmd.MarkFlagRequired("command")
+	bisect_runCmd.MarkFlagRequired("range")
+	bisectCmd.AddCommand(bisect_runCmd)
+
+	carapace.Gen(bisect_runCmd).FlagCompletion(carapace.ActionMap{
+		"command": bridge.ActionCarapaceBin().Split(),
+		"range":   jj.ActionRevSets(jj.RevOption{}.Default()),
+	})
+}
diff --git a/completers/common/jj_completer/cmd/bookmark.go b/completers/common/jj_completer/cmd/bookmark.go
@@ -6,10 +6,9 @@ import (
 )
 
 var bookmarkCmd = &cobra.Command{
-	Use:     "bookmark",
-	Short:   "Manage bookmarks",
-	Aliases: []string{"branch", "b"},
-	Run:     func(cmd *cobra.Command, args []string) {},
+	Use:   "bookmark",
+	Short: "Manage bookmarks [default alias: b]",
+	Run:   func(cmd *cobra.Command, args []string) {},
 }
 
 func init() {
diff --git a/completers/common/jj_completer/cmd/bookmark_create.go b/completers/common/jj_completer/cmd/bookmark_create.go
@@ -18,10 +18,12 @@ func init() {
 
 	bookmark_createCmd.Flags().BoolP("help", "h", false, "Print help (see more with '--help')")
 	bookmark_createCmd.Flags().StringP("revision", "r", "", "The bookmark's target revision")
+	bookmark_createCmd.Flags().String("to", "", "The bookmark's target revision")
 	bookmarkCmd.AddCommand(bookmark_createCmd)
 
 	carapace.Gen(bookmark_createCmd).FlagCompletion(carapace.ActionMap{
 		"revision": jj.ActionRevs(jj.RevOption{}.Default()),
+		"to":       jj.ActionRevs(jj.RevOption{}.Default()),
 	})
 
 	carapace.Gen(bookmark_createCmd).PositionalAnyCompletion(
diff --git a/completers/common/jj_completer/cmd/bookmark_list.go b/completers/common/jj_completer/cmd/bookmark_list.go
@@ -16,6 +16,7 @@ var bookmark_listCmd = &cobra.Command{
 func init() {
 	carapace.Gen(bookmark_listCmd).Standalone()
 
+	bookmark_listCmd.Flags().Bool("all", false, "Show all tracking and non-tracking remote bookmarks including the ones whose targets are synchronized with the local bookmarks")
 	bookmark_listCmd.Flags().BoolP("all-remotes", "a", false, "Show all tracking and non-tracking remote bookmarks including the ones whose targets are synchronized with the local bookmarks")
 	bookmark_listCmd.Flags().BoolP("conflicted", "c", false, "Show conflicted bookmarks only")
 	bookmark_listCmd.Flags().BoolP("help", "h", false, "Print help (see more with '--help')")
@@ -24,6 +25,7 @@ func init() {
 	bookmark_listCmd.Flags().StringSlice("sort", nil, "Sort bookmarks based on the given key (or multiple keys)")
 	bookmark_listCmd.Flags().StringP("template", "T", "", "Render each bookmark using the given template")
 	bookmark_listCmd.Flags().BoolP("tracked", "t", false, "Show remote tracked bookmarks only. Omits local Git-tracking bookmarks by default")
+	bookmark_listCmd.Flag("all").Hidden = true
 	bookmarkCmd.AddCommand(bookmark_listCmd)
 
 	bookmark_listCmd.MarkFlagsMutuallyExclusive("all-remotes", "conflicted")
diff --git a/completers/common/jj_completer/cmd/bookmark_set.go b/completers/common/jj_completer/cmd/bookmark_set.go
@@ -19,10 +19,12 @@ func init() {
 	bookmark_setCmd.Flags().BoolP("allow-backwards", "B", false, "Allow moving the bookmark backwards or sideways")
 	bookmark_setCmd.Flags().BoolP("help", "h", false, "Print help (see more with '--help')")
 	bookmark_setCmd.Flags().StringP("revision", "r", "", "The bookmark's target revision")
+	bookmark_setCmd.Flags().String("to", "", "The bookmark's target revision")
 	bookmarkCmd.AddCommand(bookmark_setCmd)
 
 	carapace.Gen(bookmark_setCmd).FlagCompletion(carapace.ActionMap{
 		"revision": jj.ActionRevs(jj.RevOption{}.Default()),
+		"to":       jj.ActionRevs(jj.RevOption{}.Default()),
 	})
 
 	carapace.Gen(bookmark_setCmd).PositionalAnyCompletion(
diff --git a/completers/common/jj_completer/cmd/commit.go b/completers/common/jj_completer/cmd/commit.go
@@ -7,20 +7,17 @@ import (
 )
 
 var commitCmd = &cobra.Command{
-	Use:     "commit [OPTIONS] [PATHS]...",
-	Short:   "Update the description and create a new change on top",
-	Aliases: []string{"ci"},
-	Run:     func(cmd *cobra.Command, args []string) {},
+	Use:   "commit",
+	Short: "Update the description and create a new change on top [default alias: ci]",
+	Run:   func(cmd *cobra.Command, args []string) {},
 }
 
 func init() {
 	carapace.Gen(commitCmd).Standalone()
 
-	commitCmd.Flags().String("author", "", "Set author to the provided string")
 	commitCmd.Flags().BoolP("help", "h", false, "Print help (see more with '--help')")
 	commitCmd.Flags().BoolP("interactive", "i", false, "Interactively choose which changes to include in the first commit")
 	commitCmd.Flags().StringSliceP("message", "m", nil, "The change description to use (don't open editor)")
-	commitCmd.Flags().Bool("reset-author", false, "Reset the author to the configured user")
 	commitCmd.Flags().String("tool", "", "Specify diff editor to be used (implies --interactive)")
 	rootCmd.AddCommand(commitCmd)
 
diff --git a/completers/common/jj_completer/cmd/describe.go b/completers/common/jj_completer/cmd/describe.go
@@ -16,15 +16,10 @@ var describeCmd = &cobra.Command{
 func init() {
 	carapace.Gen(describeCmd).Standalone()
 
-	describeCmd.Flags().String("author", "", "Set author to the provided string")
 	describeCmd.Flags().Bool("edit", false, "Open an editor")
 	describeCmd.Flags().BoolP("help", "h", false, "Print help (see more with '--help')")
 	describeCmd.Flags().StringSliceP("message", "m", nil, "The change description to use (don't open editor)")
-	describeCmd.Flags().Bool("no-edit", false, "Don't open an editor")
-	describeCmd.Flags().Bool("reset-author", false, "Reset the author name, email, and timestamp")
 	describeCmd.Flags().Bool("stdin", false, "Read the change description from stdin")
-
-	describeCmd.MarkFlagsMutuallyExclusive("edit", "no-edit")
 	rootCmd.AddCommand(describeCmd)
 
 	carapace.Gen(describeCmd).PositionalCompletion(
diff --git a/completers/common/jj_completer/cmd/diff.go b/completers/common/jj_completer/cmd/diff.go
@@ -24,19 +24,22 @@ func init() {
 	diffCmd.Flags().BoolP("ignore-all-space", "w", false, "Ignore whitespace when comparing lines")
 	diffCmd.Flags().BoolP("ignore-space-change", "b", false, "Ignore changes in amount of whitespace when comparing lines")
 	diffCmd.Flags().Bool("name-only", false, "For each path, show only its path")
+	diffCmd.Flags().StringSlice("revision", nil, "Show changes in these revisions")
 	diffCmd.Flags().StringSliceP("revisions", "r", nil, "Show changes in these revisions")
 	diffCmd.Flags().Bool("stat", false, "Show a histogram of the changes")
 	diffCmd.Flags().BoolP("summary", "s", false, "For each path, show only whether it was modified, added, or deleted")
 	diffCmd.Flags().StringP("template", "T", "", "Render each file diff entry using the given template")
 	diffCmd.Flags().StringP("to", "t", "", "Show changes to this revision")
 	diffCmd.Flags().String("tool", "", "Generate diff by external command")
 	diffCmd.Flags().Bool("types", false, "For each path, show only its type before and after")
+	diffCmd.Flag("revision").Hidden = true
 	rootCmd.AddCommand(diffCmd)
 
 	diffCmd.MarkFlagsMutuallyExclusive("name-only", "summary")
 
 	carapace.Gen(diffCmd).FlagCompletion(carapace.ActionMap{
 		"from":      jj.ActionRevs(jj.RevOption{}.Default()),
+		"revision":  jj.ActionRevs(jj.RevOption{}.Default()),
 		"revisions": jj.ActionRevs(jj.RevOption{}.Default()),
 		"to":        jj.ActionRevs(jj.RevOption{}.Default()),
 		"tool":      bridge.ActionCarapaceBin().Split(),
diff --git a/completers/common/jj_completer/cmd/duplicate.go b/completers/common/jj_completer/cmd/duplicate.go
@@ -15,9 +15,9 @@ var duplicateCmd = &cobra.Command{
 func init() {
 	carapace.Gen(duplicateCmd).Standalone()
 
-	duplicateCmd.Flags().StringArray("after", nil, "Alias for --insert-after")
-	duplicateCmd.Flags().StringArray("before", nil, "Alias for --insert-before")
-	duplicateCmd.Flags().StringSliceP("destination", "d", []string{"@"}, "The revision(s) to duplicate onto (can be repeated to create a merge commit)")
+	duplicateCmd.Flags().StringSlice("after", nil, "The revision(s) to insert after (can be repeated to create a merge commit)")
+	duplicateCmd.Flags().StringSlice("before", nil, "The revision(s) to insert before (can be repeated to create a merge commit)")
+	duplicateCmd.Flags().StringSliceP("destination", "d", nil, "The revision(s) to duplicate onto (can be repeated to create a merge commit)")
 	duplicateCmd.Flags().BoolP("help", "h", false, "Print help (see more with '--help')")
 	duplicateCmd.Flags().StringSliceP("insert-after", "A", nil, "The revision(s) to insert after (can be repeated to create a merge commit)")
 	duplicateCmd.Flags().StringSliceP("insert-before", "B", nil, "The revision(s) to insert before (can be repeated to create a merge commit)")
diff --git a/completers/common/jj_completer/cmd/evolog.go b/completers/common/jj_completer/cmd/evolog.go
@@ -28,15 +28,18 @@ func init() {
 	evologCmd.Flags().Bool("no-graph", false, "Don't show the graph, show a flat list of revisions")
 	evologCmd.Flags().BoolP("patch", "p", false, "Show patch compared to the previous version of this change")
 	evologCmd.Flags().Bool("reversed", false, "Show revisions in the opposite order (older revisions first)")
+	evologCmd.Flags().StringSlice("revision", nil, "Follow changes from these revisions")
 	evologCmd.Flags().StringSliceP("revisions", "r", nil, "Follow changes from these revisions")
 	evologCmd.Flags().Bool("stat", false, "Show a histogram of the changes")
 	evologCmd.Flags().BoolP("summary", "s", false, "For each path, show only whether it was modified, added, or deleted")
 	evologCmd.Flags().StringP("template", "T", "", "Render each revision using the given template")
 	evologCmd.Flags().String("tool", "", "Generate diff by external command")
 	evologCmd.Flags().Bool("types", false, "For each path, show only its type before and after")
+	evologCmd.Flag("revision").Hidden = true
 	rootCmd.AddCommand(evologCmd)
 
 	carapace.Gen(evologCmd).FlagCompletion(carapace.ActionMap{
+		"revision":  jj.ActionRevs(jj.RevOption{}.Default()),
 		"revisions": jj.ActionRevs(jj.RevOption{}.Default()),
 		"tool":      bridge.ActionCarapaceBin().Split(),
 	})
diff --git a/completers/common/jj_completer/cmd/file_annotate.go b/completers/common/jj_completer/cmd/file_annotate.go
@@ -16,7 +16,7 @@ func init() {
 	carapace.Gen(file_annotateCmd).Standalone()
 
 	file_annotateCmd.Flags().BoolP("help", "h", false, "Print help (see more with '--help')")
-	file_annotateCmd.Flags().StringP("revision", "r", "@", "an optional revision to start at")
+	file_annotateCmd.Flags().StringP("revision", "r", "", "an optional revision to start at")
 	file_annotateCmd.Flags().StringP("template", "T", "", "Render each line using the given template")
 	fileCmd.AddCommand(file_annotateCmd)
 
diff --git a/completers/common/jj_completer/cmd/gerrit.go b/completers/common/jj_completer/cmd/gerrit.go
@@ -0,0 +1,19 @@
+package cmd
+
+import (
+	"github.com/carapace-sh/carapace"
+	"github.com/spf13/cobra"
+)
+
+var gerritCmd = &cobra.Command{
+	Use:   "gerrit",
+	Short: "Interact with Gerrit Code Review",
+	Run:   func(cmd *cobra.Command, args []string) {},
+}
+
+func init() {
+	carapace.Gen(gerritCmd).Standalone()
+
+	gerritCmd.Flags().BoolP("help", "h", false, "Print help (see more with '--help')")
+	rootCmd.AddCommand(gerritCmd)
+}
diff --git a/completers/common/jj_completer/cmd/gerrit_upload.go b/completers/common/jj_completer/cmd/gerrit_upload.go
@@ -0,0 +1,29 @@
+package cmd
+
+import (
+	"github.com/carapace-sh/carapace"
+	"github.com/carapace-sh/carapace-bin/pkg/actions/tools/jj"
+	"github.com/spf13/cobra"
+)
+
+var gerrit_uploadCmd = &cobra.Command{
+	Use:   "upload",
+	Short: "Upload changes to Gerrit for code review, or update existing changes",
+	Run:   func(cmd *cobra.Command, args []string) {},
+}
+
+func init() {
+	carapace.Gen(gerrit_uploadCmd).Standalone()
+
+	gerrit_uploadCmd.Flags().BoolP("dry-run", "n", false, "Do not actually push the changes to Gerrit")
+	gerrit_uploadCmd.Flags().BoolP("help", "h", false, "Print help (see more with '--help')")
+	gerrit_uploadCmd.Flags().String("remote", "", "The Gerrit remote to push to")
+	gerrit_uploadCmd.Flags().StringP("remote-branch", "b", "", "The location where your changes are intended to land")
+	gerrit_uploadCmd.Flags().StringSliceP("revisions", "r", nil, "The revset, selecting which revisions are sent in to Gerrit")
+	gerritCmd.AddCommand(gerrit_uploadCmd)
+
+	// TODO complete gerrit flags
+	carapace.Gen(gerrit_uploadCmd).FlagCompletion(carapace.ActionMap{
+		"revisions": jj.ActionRevs(jj.RevOption{}.Default()).UniqueList(","),
+	})
+}
diff --git a/completers/common/jj_completer/cmd/git_fetch.go b/completers/common/jj_completer/cmd/git_fetch.go
@@ -16,25 +16,30 @@ func init() {
 	carapace.Gen(git_fetchCmd).Standalone()
 
 	git_fetchCmd.Flags().Bool("all-remotes", false, "Fetch from all remotes")
+	git_fetchCmd.Flags().StringSlice("bookmark", nil, "Fetch only some of the branches")
 	git_fetchCmd.Flags().StringSliceP("branch", "b", nil, "Fetch only some of the branches")
 	git_fetchCmd.Flags().BoolP("help", "h", false, "Print help (see more with '--help')")
 	git_fetchCmd.Flags().StringSlice("remote", []string{"origin"}, "The remote to fetch from (only named remotes are supported, can be repeated)")
 	git_fetchCmd.Flags().Bool("tracked", false, "Fetch only tracked bookmarks")
+	git_fetchCmd.Flag("bookmark").Hidden = true
 	gitCmd.AddCommand(git_fetchCmd)
 
-	carapace.Gen(git_fetchCmd).FlagCompletion(carapace.ActionMap{
-		"branch": carapace.ActionCallback(func(c carapace.Context) carapace.Action { // TODO verify
-			remotes, err := git_fetchCmd.Flags().GetStringSlice("remote")
-			if err != nil {
-				return carapace.ActionMessage(err.Error())
-			}
+	actionBookmarks := carapace.ActionCallback(func(c carapace.Context) carapace.Action { // TODO verify
+		remotes, err := git_fetchCmd.Flags().GetStringSlice("remote")
+		if err != nil {
+			return carapace.ActionMessage(err.Error())
+		}
+
+		batch := carapace.Batch()
+		for _, remote := range remotes {
+			batch = append(batch, jj.ActionRemoteBookmarks(remote))
+		}
+		return batch.ToA()
+	})
 
-			batch := carapace.Batch()
-			for _, remote := range remotes {
-				batch = append(batch, jj.ActionRemoteBookmarks(remote))
-			}
-			return batch.ToA()
-		}),
-		"remote": jj.ActionRemotes(),
+	carapace.Gen(git_fetchCmd).FlagCompletion(carapace.ActionMap{
+		"bookmark": actionBookmarks,
+		"branch":   actionBookmarks,
+		"remote":   jj.ActionRemotes(),
 	})
 }
diff --git a/completers/common/jj_completer/cmd/git_push.go b/completers/common/jj_completer/cmd/git_push.go
@@ -20,6 +20,7 @@ func init() {
 	git_pushCmd.Flags().BoolP("allow-new", "N", false, "Allow pushing new bookmarks")
 	git_pushCmd.Flags().Bool("allow-private", false, "Allow pushing commits that are private")
 	git_pushCmd.Flags().StringSliceP("bookmark", "b", nil, "Push only this bookmark, or bookmarks matching a pattern (can be repeated)")
+	git_pushCmd.Flags().StringSlice("branch", nil, "Push only this bookmark, or bookmarks matching a pattern (can be repeated)")
 	git_pushCmd.Flags().StringSliceP("change", "c", nil, "Push this commit by creating a bookmark (can be repeated)")
 	git_pushCmd.Flags().Bool("deleted", false, "Push all deleted bookmarks")
 	git_pushCmd.Flags().Bool("dry-run", false, "Only display what will change on the remote")
@@ -28,10 +29,12 @@ func init() {
 	git_pushCmd.Flags().String("remote", "", "The remote to push to (only named remotes are supported)")
 	git_pushCmd.Flags().StringSliceP("revisions", "r", nil, "Push bookmarks pointing to these commits (can be repeated)")
 	git_pushCmd.Flags().Bool("tracked", false, "Push all tracked bookmarks")
+	git_pushCmd.Flag("branch").Hidden = true
 	gitCmd.AddCommand(git_pushCmd)
 
 	carapace.Gen(git_pushCmd).FlagCompletion(carapace.ActionMap{
 		"bookmark":  jj.ActionLocalBookmarks(),
+		"branch":    jj.ActionLocalBookmarks(),
 		"change":    carapace.ActionValues(), // TODO
 		"remote":    jj.ActionRemotes(),
 		"revisions": jj.ActionRevSets(jj.RevOption{}.Default()),
diff --git a/completers/common/jj_completer/cmd/new.go b/completers/common/jj_completer/cmd/new.go
@@ -15,6 +15,8 @@ var newCmd = &cobra.Command{
 func init() {
 	carapace.Gen(newCmd).Standalone()
 
+	newCmd.Flags().StringSlice("after", nil, "Insert the new change after the given commit(s)")
+	newCmd.Flags().StringSlice("before", nil, "Insert the new change before the given commit(s)")
 	newCmd.Flags().BoolP("help", "h", false, "Print help (see more with '--help')")
 	newCmd.Flags().StringSliceP("insert-after", "A", nil, "Insert the new change after the given commit(s)")
 	newCmd.Flags().StringSliceP("insert-before", "B", nil, "Insert the new change before the given commit(s)")
@@ -23,6 +25,8 @@ func init() {
 	rootCmd.AddCommand(newCmd)
 
 	carapace.Gen(newCmd).FlagCompletion(carapace.ActionMap{
+		"after":         jj.ActionRevs(jj.RevOption{}.Default()).FilterArgs(),
+		"before":        jj.ActionRevs(jj.RevOption{}.Default()).FilterArgs(),
 		"insert-after":  jj.ActionRevs(jj.RevOption{}.Default()).FilterArgs(),
 		"insert-before": jj.ActionRevs(jj.RevOption{}.Default()).FilterArgs(),
 	})
diff --git a/completers/common/jj_completer/cmd/operation_diff.go b/completers/common/jj_completer/cmd/operation_diff.go
@@ -25,6 +25,7 @@ func init() {
 	operation_diffCmd.Flags().Bool("ignore-space-change", false, "Ignore changes in amount of whitespace when comparing lines")
 	operation_diffCmd.Flags().Bool("name-only", false, "For each path, show only its path")
 	operation_diffCmd.Flags().Bool("no-graph", false, "Don't show the graph, show a flat list of modified changes")
+	operation_diffCmd.Flags().String("op", "", "Show repository changes in this operation, compared to its parent")
 	operation_diffCmd.Flags().String("operation", "", "Show repository changes in this operation, compared to its parent")
 	operation_diffCmd.Flags().BoolP("patch", "p", false, "Show patch of modifications to changes")
 	operation_diffCmd.Flags().Bool("stat", false, "Show a histogram of the changes")
diff --git a/completers/common/jj_completer/cmd/rebase.go b/completers/common/jj_completer/cmd/rebase.go
@@ -15,8 +15,8 @@ var rebaseCmd = &cobra.Command{
 func init() {
 	carapace.Gen(rebaseCmd).Standalone()
 
-	rebaseCmd.Flags().StringArray("after", nil, "Alias for --insert-after")
-	rebaseCmd.Flags().StringArray("before", nil, "Alias for --insert-before")
+	rebaseCmd.Flags().StringSlice("after", nil, "The revision(s) to insert after (can be repeated to create a merge commit)")
+	rebaseCmd.Flags().StringSlice("before", nil, "The revision(s) to insert before (can be repeated to create a merge commit)")
 	rebaseCmd.Flags().StringSliceP("branch", "b", nil, "Rebase the whole branch relative to destination's ancestors (can be repeated)")
 	rebaseCmd.Flags().StringSliceP("destination", "d", nil, "The revision(s) to rebase onto (can be repeated to create a merge commit)")
 	rebaseCmd.Flags().BoolP("help", "h", false, "Print help (see more with '--help')")
diff --git a/completers/common/jj_completer/cmd/restore.go b/completers/common/jj_completer/cmd/restore.go
@@ -21,7 +21,7 @@ func init() {
 	restoreCmd.Flags().BoolP("interactive", "i", false, "Interactively choose which parts to restore")
 	restoreCmd.Flags().StringP("into", "t", "@", "Revision to restore into (destination)")
 	restoreCmd.Flags().Bool("restore-descendants", false, "Preserve the content (not the diff) when rebasing descendants")
-	restoreCmd.Flags().String("to", "@", "Revision to restore into (alias for --into)")
+	restoreCmd.Flags().String("to", "@", "Revision to restore into (destination)")
 	restoreCmd.Flags().String("tool", "", "Specify diff editor to be used (implies --interactive)")
 
 	restoreCmd.MarkFlagsMutuallyExclusive("into", "to")
diff --git a/completers/common/jj_completer/cmd/revert.go b/completers/common/jj_completer/cmd/revert.go
@@ -14,6 +14,8 @@ var revertCmd = &cobra.Command{
 func init() {
 	carapace.Gen(revertCmd).Standalone()
 
+	revertCmd.Flags().StringSlice("after", nil, "The revision(s) to insert the reverse changes after (can be repeated to create a merge commit)")
+	revertCmd.Flags().StringSlice("before", nil, "The revision(s) to insert the reverse changes before (can be repeated to create a merge commit)")
 	revertCmd.Flags().StringSliceP("destination", "d", nil, "The revision(s) to apply the reverse changes on top of")
 	revertCmd.Flags().BoolP("help", "h", false, "Print help (see more with '--help')")
 	revertCmd.Flags().StringSliceP("insert-after", "A", nil, "The revision(s) to insert the reverse changes after (can be repeated to create a merge commit)")
diff --git a/completers/common/jj_completer/cmd/split.go b/completers/common/jj_completer/cmd/split.go
diff --git a/completers/common/jj_completer/cmd/squash.go b/completers/common/jj_completer/cmd/squash.go
diff --git a/completers/common/jj_completer/cmd/status.go b/completers/common/jj_completer/cmd/status.go

Original file line number	Diff line number	Diff line change
`@@ -6,10 +6,9 @@ import (`
`6`	`6`	`)`
`7`	`7`
`8`	`8`	`var bookmarkCmd = &cobra.Command{`
`9`		`- Use: "bookmark",`
`10`		`- Short: "Manage bookmarks",`
`11`		`- Aliases: []string{"branch", "b"},`
`12`		`- Run: func(cmd *cobra.Command, args []string) {},`
	`9`	`+ Use: "bookmark",`
	`10`	`+ Short: "Manage bookmarks [default alias: b]",`
	`11`	`+ Run: func(cmd *cobra.Command, args []string) {},`
`13`	`12`	`}`
`14`	`13`
`15`	`14`	`func init() {`