feat(cli): add Antigravity CLI statusline support

Add the `oh-my-posh antigravity` command and matching segment, mirroring
the existing Claude Code and GitHub Copilot CLI integrations: same
workspace.current_dir/cwd fallback for directory-aware segments, same
token-gauge template shape. Field set is based on Antigravity CLI's
published statusline JSON schema.

Closes #7806

Author: JanDeDobbeleer

src/cache/cache.go

@@ -33,6 +33,7 @@ const (
 	FONTLISTCACHE    = "font_list_cache"
 	CLAUDECACHE      = "claude_cache"
 	COPILOTCLICACHE  = "copilot_cli_cache"
+	ANTIGRAVITYCACHE = "antigravity_cache"
 )
 
 type Entry[T any] struct {

src/cli/antigravity.go

@@ -0,0 +1,44 @@
+package cli
+
+import (
+	"github.com/jandedobbeleer/oh-my-posh/src/cache"
+	"github.com/jandedobbeleer/oh-my-posh/src/config"
+	"github.com/jandedobbeleer/oh-my-posh/src/segments"
+	"github.com/jandedobbeleer/oh-my-posh/src/shell"
+
+	"github.com/jandedobbeleer/oh-my-posh/src/cmdtree"
+)
+
+var antigravityCmd = &cmdtree.Command{
+	Use:   "antigravity",
+	Short: "Render a prompt for Antigravity CLI statusline",
+	Long: `Render a prompt for Antigravity CLI statusline integration.
+
+This command reads Antigravity CLI's contextual JSON data from stdin and renders
+a prompt that can include an Antigravity segment with session information like
+model name, token usage, and more.
+
+Example usage in Antigravity CLI settings (~/.gemini/antigravity-cli/settings.json):
+  {
+    "statusLine": {
+      "type": "command",
+      "command": "oh-my-posh antigravity --config ~/.config/ohmyposh/antigravity.toml"
+    }
+  }`,
+	Args: cmdtree.NoArgs,
+	Run: statuslineRun(
+		shell.ANTIGRAVITY,
+		cache.ANTIGRAVITYCACHE,
+		func(d *segments.AntigravityData) string { return d.SessionID },
+		antigravityPWD,
+		config.Antigravity,
+	),
+}
+
+func init() {
+	RootCmd.AddCommand(antigravityCmd)
+}
+
+func antigravityPWD(d *segments.AntigravityData) string {
+	return workingDirectory(d.Workspace.CurrentDir, d.CWD)
+}

src/cli/statusline_test.go

@@ -134,6 +134,44 @@ func TestCopilotPWD(t *testing.T) {
 	}
 }
 
+func TestAntigravityPWD(t *testing.T) {
+	cases := []struct {
+		Case     string
+		Data     *segments.AntigravityData
+		Expected string
+	}{
+		{
+			Case:     "both set, disagreeing: current_dir wins",
+			Data:     &segments.AntigravityData{CWD: "/b", Workspace: segments.AntigravityWorkspace{CurrentDir: "/a"}},
+			Expected: "/a",
+		},
+		{
+			Case:     "only current_dir",
+			Data:     &segments.AntigravityData{Workspace: segments.AntigravityWorkspace{CurrentDir: "/a"}},
+			Expected: "/a",
+		},
+		{
+			Case:     "only cwd",
+			Data:     &segments.AntigravityData{CWD: "/b"},
+			Expected: "/b",
+		},
+		{
+			Case:     "neither",
+			Data:     &segments.AntigravityData{},
+			Expected: "",
+		},
+		{
+			Case:     "project_dir is not a fallback",
+			Data:     &segments.AntigravityData{Workspace: segments.AntigravityWorkspace{ProjectDir: "/p"}},
+			Expected: "",
+		},
+	}
+
+	for _, tc := range cases {
+		assert.Equal(t, tc.Expected, antigravityPWD(tc.Data), tc.Case)
+	}
+}
+
 func TestRunStatuslineRendersToWriter(t *testing.T) {
 	t.Setenv("OMP_CACHE_DIR", t.TempDir())
 	t.Setenv("POSH_SESSION_ID", "d4-writer")

src/config/default.go

@@ -235,6 +235,10 @@ func CopilotCLI() *Config {
 	return statuslineCLIConfig(1234567891, COPILOTCLI, " \uec1e {{ .Model.DisplayName }} \uf2d0 {{ .TokenGauge }} ")
 }
 
+func Antigravity() *Config {
+	return statuslineCLIConfig(1234567892, ANTIGRAVITY, " \uf135 {{ .Model.DisplayName }} \uf2d0 {{ .TokenGauge }} ")
+}
+
 // The left block is always PATH + GIT; the right block contains a single
 // segment of the given type and template.
 func statuslineCLIConfig(hash uint64, segmentType SegmentType, template string) *Config {

src/config/segment_registry.go

@@ -25,6 +25,8 @@ func newSegmentWriter(segmentType SegmentType) (SegmentWriter, error) {
 func init() {
 	gob.Register(&segments.Angular{})
 	gob.Register(&segments.Version{})
+	gob.Register(&segments.Antigravity{})
+	gob.Register(&segments.AntigravityData{})
 	gob.Register(&segments.Argocd{})
 	gob.Register(&segments.Aspire{})
 	gob.Register(&segments.Aurelia{})
@@ -144,6 +146,7 @@ func init() {
 
 var Segments = map[SegmentType]func() SegmentWriter{
 	ANGULAR:         func() SegmentWriter { return &segments.Angular{} },
+	ANTIGRAVITY:     func() SegmentWriter { return &segments.Antigravity{} },
 	ARGOCD:          func() SegmentWriter { return &segments.Argocd{} },
 	ASPIRE:          func() SegmentWriter { return &segments.Aspire{} },
 	AURELIA:         func() SegmentWriter { return &segments.Aurelia{} },

src/config/segment_types.go

@@ -30,6 +30,8 @@ const (
 	Diamond SegmentStyle = "diamond"
 	// ANGULAR writes which angular cli version us currently active
 	ANGULAR SegmentType = "angular"
+	// ANTIGRAVITY writes Antigravity CLI session information
+	ANTIGRAVITY SegmentType = "antigravity"
 	// ARGOCD writes the current argocd context
 	ARGOCD SegmentType = "argocd"
 	// ASPIRE writes the Aspire apphost status

src/segments/antigravity.go

@@ -0,0 +1,200 @@
+package segments
+
+import (
+	"github.com/jandedobbeleer/oh-my-posh/src/cache"
+	"github.com/jandedobbeleer/oh-my-posh/src/log"
+	"github.com/jandedobbeleer/oh-my-posh/src/text"
+)
+
+type Antigravity struct {
+	Base
+	markedChar   string
+	unmarkedChar string
+	AntigravityData
+}
+
+type AntigravityData struct {
+	Quota                   map[string]AntigravityQuota `json:"quota"`
+	VCS                     *AntigravityVCS             `json:"vcs"`
+	Sandbox                 *AntigravitySandbox         `json:"sandbox"`
+	Vim                     *ClaudeVim                  `json:"vim"`
+	Model                   AIModel                     `json:"model"`
+	Workspace               AntigravityWorkspace        `json:"workspace"`
+	TranscriptPath          string                      `json:"transcript_path"`
+	CWD                     string                      `json:"cwd"`
+	SessionID               string                      `json:"session_id"`
+	ConversationID          string                      `json:"conversation_id"`
+	Version                 string                      `json:"version"`
+	Product                 string                      `json:"product"`
+	AgentState              string                      `json:"agent_state"`
+	PlanTier                string                      `json:"plan_tier"`
+	Email                   string                      `json:"email"`
+	ExecutionMode           string                      `json:"execution_mode"`
+	ContextWindow           AntigravityContextWindow    `json:"context_window"`
+	ArtifactCount           int                         `json:"artifact_count"`
+	PendingInputCount       int                         `json:"pending_input_count"`
+	TaskCount               int                         `json:"task_count"`
+	TerminalWidth           int                         `json:"terminal_width"`
+	Exceeds200KTokens       bool                        `json:"exceeds_200k_tokens"`
+	ToolConfirmationPending bool                        `json:"tool_confirmation_pending"`
+}
+
+type AntigravityWorkspace struct {
+	CurrentDir string `json:"current_dir"`
+	ProjectDir string `json:"project_dir"`
+}
+
+type AntigravityContextWindow struct {
+	CurrentUsage        *AntigravityCurrentUsage `json:"current_usage"`
+	UsedPercentage      *float64                 `json:"used_percentage"`
+	RemainingPercentage *float64                 `json:"remaining_percentage"`
+	TotalInputTokens    int                      `json:"total_input_tokens"`
+	TotalOutputTokens   int                      `json:"total_output_tokens"`
+	ContextWindowSize   int                      `json:"context_window_size"`
+}
+
+// Reflects the last API call, not a cumulative total.
+type AntigravityCurrentUsage struct {
+	InputTokens              int `json:"input_tokens"`
+	OutputTokens             int `json:"output_tokens"`
+	CacheCreationInputTokens int `json:"cache_creation_input_tokens"`
+	CacheReadInputTokens     int `json:"cache_read_input_tokens"`
+}
+
+// Keyed by a model or quota bucket id (e.g. "gemini-weekly"), not necessarily a model id.
+type AntigravityQuota struct {
+	RemainingFraction *float64 `json:"remaining_fraction"`
+	ResetInSeconds    *int     `json:"reset_in_seconds"`
+	ResetTime         string   `json:"reset_time"`
+}
+
+// Nil when the session is not backed by a VCS checkout.
+type AntigravityVCS struct {
+	Type   string `json:"type"`
+	Branch string `json:"branch"`
+	Dirty  bool   `json:"dirty"`
+}
+
+// Nil when sandboxing is not in use.
+type AntigravitySandbox struct {
+	AllowNetwork *bool `json:"allow_network"`
+	Enabled      bool  `json:"enabled"`
+}
+
+func (a *Antigravity) Template() string {
+	return " \uf135 {{ .Model.DisplayName }} \uf2d0 {{ .TokenGauge }} "
+}
+
+func (a *Antigravity) Enabled() bool {
+	log.Debug("antigravity segment: checking if enabled")
+
+	data, found := cache.Get[AntigravityData](cache.Session, cache.ANTIGRAVITYCACHE)
+	if !found {
+		log.Debug("antigravity segment: no data found in session cache")
+		return false
+	}
+
+	log.Debug("antigravity segment: found data in session cache")
+	log.Debugf("antigravity segment: model=%s, session=%s", data.Model.DisplayName, data.SessionID)
+
+	a.AntigravityData = data
+
+	a.markedChar = a.options.String(gaugeMarkedChar, "▰")
+	a.unmarkedChar = a.options.String(gaugeUnmarkedChar, "▱")
+
+	return true
+}
+
+// Uses pre-calculated UsedPercentage when available, falls back to calculating from
+// CurrentUsage, then to total tokens for backwards compatibility.
+func (a *Antigravity) TokenUsagePercent() text.Percentage {
+	if a.ContextWindow.UsedPercentage != nil {
+		v := *a.ContextWindow.UsedPercentage
+		if v > 100 {
+			return 100
+		}
+
+		if v < 0 {
+			return 0
+		}
+
+		return text.Percentage(int(v + 0.5))
+	}
+
+	if a.ContextWindow.ContextWindowSize <= 0 {
+		return 0
+	}
+
+	var currentTokens int
+	if a.ContextWindow.CurrentUsage != nil {
+		currentTokens = a.ContextWindow.CurrentUsage.InputTokens +
+			a.ContextWindow.CurrentUsage.CacheCreationInputTokens +
+			a.ContextWindow.CurrentUsage.CacheReadInputTokens
+	}
+
+	if currentTokens <= 0 {
+		currentTokens = a.ContextWindow.TotalInputTokens + a.ContextWindow.TotalOutputTokens
+	}
+
+	if currentTokens <= 0 {
+		return 0
+	}
+
+	percent := (float64(currentTokens) * 100.0) / float64(a.ContextWindow.ContextWindowSize)
+
+	rounded := int(percent + 0.5)
+	if rounded > 100 {
+		return 100
+	}
+
+	return text.Percentage(rounded)
+}
+
+// Shows remaining capacity; see TokenGaugeUsed for the used view.
+func (a *Antigravity) TokenGauge() string {
+	return a.TokenUsagePercent().GaugeWith(a.markedChar, a.unmarkedChar)
+}
+
+// Shows used capacity, unlike TokenGauge which shows remaining.
+func (a *Antigravity) TokenGaugeUsed() string {
+	return a.TokenUsagePercent().GaugeUsedWith(a.markedChar, a.unmarkedChar)
+}
+
+// Uses CurrentUsage (actual context, resets on compact/clear), falling back to total tokens.
+func (a *Antigravity) FormattedTokens() string {
+	var currentTokens int
+
+	if a.ContextWindow.CurrentUsage != nil {
+		currentTokens = a.ContextWindow.CurrentUsage.InputTokens +
+			a.ContextWindow.CurrentUsage.CacheCreationInputTokens +
+			a.ContextWindow.CurrentUsage.CacheReadInputTokens
+	}
+
+	if currentTokens <= 0 {
+		currentTokens = a.ContextWindow.TotalInputTokens + a.ContextWindow.TotalOutputTokens
+	}
+
+	return formatTokenCount(currentTokens)
+}
+
+func (a *Antigravity) RemainingPercent() text.Percentage {
+	if a.ContextWindow.RemainingPercentage != nil {
+		v := *a.ContextWindow.RemainingPercentage
+		if v > 100 {
+			return 100
+		}
+
+		if v < 0 {
+			return 0
+		}
+
+		return text.Percentage(int(v + 0.5))
+	}
+
+	remaining := 100 - int(a.TokenUsagePercent())
+	if remaining < 0 {
+		return 0
+	}
+
+	return text.Percentage(remaining)
+}