Add Antigravity CLI

Add Antigravity CLI and a required back button from chats + fix batch/folder specific import

Author: RoyCoding8

README.md

@@ -9,7 +9,7 @@ Native desktop GUI for managing AI coding-agent configuration across providers.
 - **Scope Switching** — project-level vs global configuration, with workspace browser.
 - **Diff Workbench** — compare project and global configs with stable, secret-safe fingerprints. Detects duplicates, missing targets, and scope conflicts.
 - **Hook Cockpit** — static hook inventory showing event, matcher, handler, blocking risk, timeout, duplicates, and project/global overlaps.
-- **Chat Manager** — unified chat history browser across Claude Code, Codex CLI, Gemini CLI, and Kiro. Search, export (single JSON or multi-chat ZIP), soft-delete with Trash, and import archived sessions.
+- **Chat Manager** — unified chat history browser across Claude Code, Codex CLI, Gemini CLI, Antigravity CLI, and Kiro. Search, export (single JSON or multi-chat ZIP), soft-delete with Trash, and import archived sessions.
 - **Inline Editor** — edit instruction files, rules, and steering docs without leaving the app.
 - **JSON Backups** — automatic `.bak` creation before any config mutation.
 - **Cross-platform** — Windows, Linux, and macOS builds.
@@ -21,6 +21,7 @@ Native desktop GUI for managing AI coding-agent configuration across providers.
 | Claude Code | `CLAUDE.md` | `.claude/skills/` | `settings.json` | `settings.json` | Rules |
 | Codex CLI | `AGENTS.md` | `.codex/skills/`, `.agents/skills/` | `config.toml`, `hooks.json` | `config.toml`, `.mcp.json` | — |
 | Gemini CLI | `GEMINI.md`, `AGENTS.md` | `.gemini/skills/` | `settings.json` | `settings.json` | Rules |
+| Antigravity CLI | `GEMINI.md`, `AGENTS.md` | `.agents/skills/` | `settings.json` | `mcp_config.json` | — |
 | Kiro | — | — | Agent JSON | `settings/mcp.json` | Steering, Specs, Agents |
 | OpenCode | `AGENTS.md` | `.opencode/skills/` | Plugins | `opencode.json` | Agents |
 

src/app.rs

@@ -390,6 +390,16 @@ impl eframe::App for App {
 impl App {
     fn show_chats(&mut self, ui_panel: &mut egui::Ui) {
         ui_panel.horizontal(|ui| {
+            if ui.button("Back").clicked() {
+                if self.selected_provider.is_none() {
+                    self.selected_provider = self
+                        .providers
+                        .iter()
+                        .find(|(_, exists)| *exists)
+                        .map(|(id, _)| *id);
+                }
+                self.view = View::Items;
+            }
             ui.label(
                 egui::RichText::new(if self.chat_trash_mode {
                     "Chats Trash"
@@ -428,15 +438,36 @@ impl App {
         }
         if action.import {
             if let Some(path) = rfd::FileDialog::new()
-                .add_filter("AgentSwitch chat", &["json"])
+                .add_filter("AgentSwitch chat/zip", &["json", "zip"])
+                .set_directory(chat::exports_dir())
                 .pick_file()
             {
-                match chat::import_archive(&path) {
-                    Ok(_) => {
-                        self.rescan_chats();
-                        self.status_msg = Some("Chat imported".into());
+                let project_dir = rfd::FileDialog::new()
+                    .set_title("Associate with project directory (Cancel to skip)")
+                    .pick_folder();
+                let is_zip = path
+                    .extension()
+                    .and_then(|e| e.to_str())
+                    .is_some_and(|e| e.eq_ignore_ascii_case("zip"));
+                if is_zip {
+                    match chat::import_zip(&path, project_dir.as_deref()) {
+                        Ok(report) => {
+                            self.rescan_chats();
+                            self.status_msg = Some(format!(
+                                "{} chats imported, {} failed",
+                                report.ok, report.failed
+                            ));
+                        }
+                        Err(e) => self.status_msg = Some(format!("Import error: {e}")),
+                    }
+                } else {
+                    match chat::import_archive(&path, project_dir.as_deref()) {
+                        Ok(_) => {
+                            self.rescan_chats();
+                            self.status_msg = Some("Chat imported".into());
+                        }
+                        Err(e) => self.status_msg = Some(format!("Import error: {e}")),
                     }
-                    Err(e) => self.status_msg = Some(format!("Import error: {e}")),
                 }
             }
         }
@@ -446,11 +477,13 @@ impl App {
                 .iter()
                 .filter_map(|idx| self.chat_sessions.get(*idx).cloned())
                 .collect();
+            let _ = std::fs::create_dir_all(chat::exports_dir());
             if sessions.len() == 1 {
                 let session = &sessions[0];
                 if let Some(path) = rfd::FileDialog::new()
                     .add_filter("AgentSwitch chat", &["json"])
                     .set_file_name(chat::suggested_export_name(session))
+                    .set_directory(chat::exports_dir())
                     .save_file()
                 {
                     match chat::export_session(session, &path) {
@@ -462,6 +495,7 @@ impl App {
                 if let Some(path) = rfd::FileDialog::new()
                     .add_filter("AgentSwitch chats", &["zip"])
                     .set_file_name(chat::suggested_zip_export_name())
+                    .set_directory(chat::exports_dir())
                     .save_file()
                 {
                     match chat::export_sessions_zip(&sessions, &path) {
@@ -586,6 +620,10 @@ fn instruction_files(provider: ProviderId, root: &Path, dir: &Path, scope: Scope
             vec![root.join("GEMINI.md"), root.join("AGENTS.md")]
         }
         (ProviderId::Gemini, Scope::Global) => vec![dir.join("GEMINI.md")],
+        (ProviderId::Antigravity, Scope::Project) => {
+            vec![root.join("GEMINI.md"), root.join("AGENTS.md")]
+        }
+        (ProviderId::Antigravity, Scope::Global) => vec![dir.join("GEMINI.md")],
         (ProviderId::Kiro, Scope::Project) => {
             vec![root.join(".kiro").join("steering").join("instructions.md")]
         }

src/chat.rs

@@ -11,7 +11,7 @@ use std::{
     time::{SystemTime, UNIX_EPOCH},
 };
 use walkdir::WalkDir;
-use zip::{write::SimpleFileOptions, CompressionMethod, ZipWriter};
+use zip::{read::ZipArchive, write::SimpleFileOptions, CompressionMethod, ZipWriter};
 
 const ARCHIVE_VERSION: u32 = 1;
 const ARCHIVE_EXT: &str = "agentswitch-chat.json";
@@ -21,6 +21,7 @@ pub enum ChatProvider {
     Claude,
     Codex,
     Gemini,
+    Antigravity,
     Kiro,
 }
 
@@ -30,6 +31,7 @@ impl ChatProvider {
             Self::Claude => "Claude Code",
             Self::Codex => "Codex CLI",
             Self::Gemini => "Gemini CLI",
+            Self::Antigravity => "Antigravity CLI",
             Self::Kiro => "Kiro",
         }
     }
@@ -39,6 +41,7 @@ impl ChatProvider {
             Self::Claude => "claude",
             Self::Codex => "codex",
             Self::Gemini => "gemini",
+            Self::Antigravity => "antigravity",
             Self::Kiro => "kiro",
         }
     }
@@ -48,6 +51,7 @@ impl ChatProvider {
             Self::Claude => ProviderId::Claude.color(),
             Self::Codex => ProviderId::Codex.color(),
             Self::Gemini => ProviderId::Gemini.color(),
+            Self::Antigravity => ProviderId::Antigravity.color(),
             Self::Kiro => ProviderId::Kiro.color(),
         }
     }
@@ -160,6 +164,7 @@ pub fn scan_all(workspace: &Path) -> Vec<ChatSession> {
     sessions.extend(scan_claude());
     sessions.extend(scan_codex());
     sessions.extend(scan_gemini());
+    sessions.extend(scan_antigravity());
     sessions.extend(scan_kiro(workspace));
     sessions.extend(scan_imported());
     sessions.sort_by(|a, b| {
@@ -263,9 +268,12 @@ pub fn export_sessions_zip(sessions: &[ChatSession], target: &Path) -> Result<Ba
     Ok(report)
 }
 
-pub fn import_archive(path: &Path) -> Result<PathBuf> {
-    let archive: ChatArchive = serde_json::from_str(&fs::read_to_string(path)?)?;
+pub fn import_archive(path: &Path, project_dir: Option<&Path>) -> Result<PathBuf> {
+    let mut archive: ChatArchive = serde_json::from_str(&fs::read_to_string(path)?)?;
     validate_archive(&archive)?;
+    if let Some(dir) = project_dir {
+        archive.project_path = dir.to_string_lossy().to_string();
+    }
     let dir = imports_dir();
     fs::create_dir_all(&dir)?;
     let base = safe_file_stem(&format!(
@@ -279,10 +287,59 @@ pub fn import_archive(path: &Path) -> Result<PathBuf> {
         target = dir.join(format!("{base}-{n}.{ARCHIVE_EXT}"));
         n += 1;
     }
-    fs::copy(path, &target)?;
+    fs::write(&target, serde_json::to_string_pretty(&archive)?)?;
     Ok(target)
 }
 
+pub fn import_zip(path: &Path, project_dir: Option<&Path>) -> Result<BatchReport> {
+    let file = File::open(path)?;
+    let mut zip = ZipArchive::new(file)?;
+    let dir = imports_dir();
+    fs::create_dir_all(&dir)?;
+    let mut report = BatchReport::default();
+    for i in 0..zip.len() {
+        let mut entry = zip.by_index(i)?;
+        let name = entry.name().to_string();
+        if !name.ends_with(ARCHIVE_EXT) {
+            continue;
+        }
+        let mut buf = String::new();
+        std::io::Read::read_to_string(&mut entry, &mut buf)?;
+        let mut archive: ChatArchive = match serde_json::from_str(&buf) {
+            Ok(a) => a,
+            Err(_) => {
+                report.failed += 1;
+                continue;
+            }
+        };
+        if validate_archive(&archive).is_err() {
+            report.failed += 1;
+            continue;
+        }
+        if let Some(d) = project_dir {
+            archive.project_path = d.to_string_lossy().to_string();
+        }
+        let base = safe_file_stem(&format!(
+            "{}-{}",
+            archive.source_provider.id(),
+            archive.title
+        ));
+        let mut target = dir.join(format!("{base}.{ARCHIVE_EXT}"));
+        let mut n = 2usize;
+        while target.exists() {
+            target = dir.join(format!("{base}-{n}.{ARCHIVE_EXT}"));
+            n += 1;
+        }
+        fs::write(&target, serde_json::to_string_pretty(&archive)?)?;
+        report.ok += 1;
+    }
+    Ok(report)
+}
+
+pub fn exports_dir() -> PathBuf {
+    data_dir().join("chats").join("exports")
+}
+
 pub fn soft_delete(session: &ChatSession, workspace: &Path) -> Result<()> {
     let _ = workspace;
     if session.source_kind == ChatSourceKind::KiroCli {
@@ -593,6 +650,59 @@ fn scan_gemini() -> Vec<ChatSession> {
     out
 }
 
+fn scan_antigravity() -> Vec<ChatSession> {
+    let Some(home) = dirs::home_dir() else {
+        return vec![];
+    };
+    let tmp = home.join(".gemini").join("antigravity-cli").join("tmp");
+    if !tmp.is_dir() {
+        return vec![];
+    }
+    let mut out = Vec::new();
+    let Ok(projects) = fs::read_dir(&tmp) else {
+        return out;
+    };
+    for project in projects.flatten().filter(|e| e.path().is_dir()) {
+        let chats = project.path().join("chats");
+        if let Ok(entries) = fs::read_dir(&chats) {
+            for entry in entries.flatten() {
+                let path = entry.path();
+                if path.is_file() && is_gemini_session_file(&path) {
+                    if let Ok(session) = jsonl_session(ChatProvider::Antigravity, &tmp, &path) {
+                        if session.turn_count > 0 {
+                            out.push(session);
+                        }
+                    }
+                } else if path.is_dir() {
+                    let files = jsonl_files_in(&path, 1);
+                    if !files.is_empty() {
+                        if let Ok(session) =
+                            jsonl_dir_session(ChatProvider::Antigravity, &tmp, &path, files)
+                        {
+                            if session.turn_count > 0 {
+                                out.push(session);
+                            }
+                        }
+                    }
+                }
+            }
+        }
+        if let Ok(entries) = fs::read_dir(project.path()) {
+            for entry in entries.flatten() {
+                let path = entry.path();
+                if path.is_file() && is_gemini_checkpoint_file(&path) {
+                    if let Ok(session) = jsonl_session(ChatProvider::Antigravity, &tmp, &path) {
+                        if session.turn_count > 0 {
+                            out.push(session);
+                        }
+                    }
+                }
+            }
+        }
+    }
+    out
+}
+
 fn scan_kiro(workspace: &Path) -> Vec<ChatSession> {
     let _ = workspace;
     let Some(home) = dirs::home_dir() else {
@@ -983,6 +1093,10 @@ fn update_meta_from_event(provider: ChatProvider, value: &Value, meta: &mut Sess
         meta.project_path =
             str_field(value, &["projectHash"]).map(|s| format!("Gemini project {s}"));
     }
+    if meta.project_path.is_none() && provider == ChatProvider::Antigravity {
+        meta.project_path =
+            str_field(value, &["projectHash"]).map(|s| format!("Antigravity project {s}"));
+    }
 }
 
 fn tool_title(value: &Value) -> Option<&str> {
@@ -1184,6 +1298,12 @@ fn project_label_from_path(provider: ChatProvider, root: &Path, path: &Path) ->
             .and_then(|p| p.components().next())
             .map(|c| c.as_os_str().to_string_lossy().to_string())
             .unwrap_or_else(|| "Gemini project".into()),
+        ChatProvider::Antigravity => path
+            .strip_prefix(root)
+            .ok()
+            .and_then(|p| p.components().next())
+            .map(|c| c.as_os_str().to_string_lossy().to_string())
+            .unwrap_or_else(|| "Antigravity project".into()),
         _ => path
             .parent()
             .map(|p| p.to_string_lossy().to_string())

src/scanner.rs

@@ -6,6 +6,7 @@ pub fn scan_provider(id: ProviderId, root: &Path, scope: Scope) -> Vec<ConfigIte
         ProviderId::Claude => scan_claude(root, scope),
         ProviderId::Codex => scan_codex(root, scope),
         ProviderId::Gemini => scan_gemini(root, scope),
+        ProviderId::Antigravity => scan_antigravity(root, scope),
         ProviderId::Kiro => scan_kiro(root, scope),
         ProviderId::OpenCode => scan_opencode(root, scope),
     }
@@ -24,6 +25,11 @@ pub fn provider_exists(id: ProviderId, root: &Path, scope: Scope) -> bool {
             provider_dir(id, root, scope).is_dir() || has_cmd("codex")
         }
         (ProviderId::Gemini, _) => provider_dir(id, root, scope).is_dir() || has_cmd("gemini"),
+        (ProviderId::Antigravity, _) => {
+            provider_dir(id, root, scope).is_dir()
+                || root.join(".agents").is_dir()
+                || has_cmd("agy")
+        }
         (ProviderId::Kiro, _) => {
             provider_dir(id, root, scope).is_dir() || has_cmd("kiro") || has_cmd("kiro-cli")
         }
@@ -40,6 +46,8 @@ pub fn provider_dir(id: ProviderId, root: &Path, scope: Scope) -> PathBuf {
         (ProviderId::Codex, Scope::Global) => home.join(".codex"),
         (ProviderId::Gemini, Scope::Project) => root.join(".gemini"),
         (ProviderId::Gemini, Scope::Global) => home.join(".gemini"),
+        (ProviderId::Antigravity, Scope::Project) => root.join(".agents"),
+        (ProviderId::Antigravity, Scope::Global) => home.join(".gemini").join("antigravity-cli"),
         (ProviderId::Kiro, Scope::Project) => root.join(".kiro"),
         (ProviderId::Kiro, Scope::Global) => home.join(".kiro"),
         (ProviderId::OpenCode, Scope::Project) => root.join(".opencode"),
@@ -519,6 +527,38 @@ fn scan_gemini(root: &Path, scope: Scope) -> Vec<ConfigItem> {
     items
 }
 
+fn scan_antigravity(root: &Path, scope: Scope) -> Vec<ConfigItem> {
+    let d = provider_dir(ProviderId::Antigravity, root, scope);
+    let mut items = vec![];
+    if scope == Scope::Project {
+        items.extend(check_file(
+            root.join("GEMINI.md"),
+            ItemKind::InstructionFile,
+            ProviderId::Antigravity,
+        ));
+        items.extend(check_file(
+            root.join("AGENTS.md"),
+            ItemKind::InstructionFile,
+            ProviderId::Antigravity,
+        ));
+    }
+    items.extend(collect_subdirs_both(
+        &d.join("skills"),
+        ItemKind::Skill,
+        ProviderId::Antigravity,
+    ));
+    let mcp_cfg = d.join("mcp_config.json");
+    items.extend(scan_json_keys(
+        &mcp_cfg,
+        "mcpServers",
+        ItemKind::Mcp,
+        ProviderId::Antigravity,
+    ));
+    let settings = d.join("settings.json");
+    items.extend(scan_hook_entries(&settings, ProviderId::Antigravity, &[]));
+    items
+}
+
 fn scan_kiro(root: &Path, scope: Scope) -> Vec<ConfigItem> {
     let d = provider_dir(ProviderId::Kiro, root, scope);
     let mut items = vec![];

src/toggler.rs

@@ -39,7 +39,7 @@ pub fn toggle_item(item: &mut ConfigItem) -> Result<()> {
 }
 
 fn toggle_hook(item: &mut ConfigItem, loc: &HookLoc) -> Result<()> {
-    if item.provider == ProviderId::Gemini {
+    if item.provider == ProviderId::Gemini || item.provider == ProviderId::Antigravity {
         return toggle_gemini_hook(item, loc);
     }
     toggle_hook_stash(item, loc)