Add GUI support for preset provider imports (#99)

* feat: add GUI for preset provider imports

Add graphical interface for importing chat sessions from preset provider
directories, complementing existing file-based import functionality.

Backend changes:
- Add import_from_provider Tauri command supporting all/claude/gemini/codex
- Implement ImportStats struct for cleaner parameter management
- Integrate with existing ImportService and provider configs
- Support batch importing from multiple provider directories

Frontend changes:
- Add import method selection dialog with file and preset options
- Create provider selection UI with All/Claude/Gemini/Codex cards
- Add toast notifications for import progress and results
- Auto-refresh session list after successful imports

Technical notes:
- Passes cargo clippy -- -D warnings
- Passes pnpm biome:check
- Follows existing architecture patterns

Generated with [Claude Code](https://claude.com/claude-code)

Co-Authored-By: Claude <noreply@anthropic.com>

* refactor: address code review feedback for preset import GUI

Improvements based on code review:

1. Concurrency Control:
   - Add isImporting state to prevent concurrent imports
   - Show warning toast if import attempted while one is in progress
   - Disable all import buttons during import operation

2. Enhanced Error Messages:
   - Show detailed error information for failed imports
   - Display first 3 failed files with their error messages
   - Add "+N more" indicator if more than 3 failures

3. Accessibility:
   - Add descriptive ARIA labels to all import buttons
   - Labels describe what each button does for screen readers
   - Include provider directory paths in labels

4. User Experience:
   - Buttons visually disabled during import (opacity + cursor)
   - Better error context for debugging issues
   - More informative toast notifications

Technical notes:
- Passes pnpm biome:check
- All functionality tested and verified

Generated with [Claude Code](https://claude.com/claude-code)

Co-Authored-By: Claude <noreply@anthropic.com>

* refactor: simplify error messages to show only success count

Remove verbose error details from toast notifications.
Now shows: 'Imported 5/10 files (50 sessions, 200 messages)'
instead of listing individual file errors.

Error details are still logged to console for debugging.

* refactor: simplify dialog animation to fade only

Remove slide and zoom animations from dialog.
Now uses simple opacity fade for cleaner appearance.

Before: Dialog slid in from top-left with zoom
After: Dialog fades in at center position

* revert: restore default shadcn Dialog animations

Keep the standard shadcn Dialog component with original animations.
The default behavior works well for most use cases.

* refactor: customize Dialog to use fade-only animation

Remove slide and zoom animations from Dialog component.
Now uses simple opacity fade for cleaner UX.

Changes:
- Removed slide-in/out animations
- Removed zoom-in/out effects
- Kept fade-in/out for smooth transitions

* refactor: slow down Dialog animation to reduce flashing

Increase animation duration from 200ms to 300ms.
Makes the fade transition smoother and less jarring.

---------

Co-authored-by: Claude <noreply@anthropic.com>

Author: sanggggg

src-tauri/src/commands/file.rs

@@ -1,6 +1,8 @@
 use crate::dto::{ImportFileResult, ImportSessionsResponse};
 use crate::{AppState, OpenedFiles};
-use retrochat::services::ImportFileRequest;
+use retrochat::models::provider::config::{ClaudeCodeConfig, CodexConfig, GeminiCliConfig};
+use retrochat::models::Provider;
+use retrochat::services::{BatchImportRequest, ImportFileRequest};
 use std::path::PathBuf;
 use std::sync::Arc;
 use tauri::{AppHandle, Emitter, Manager, State};
@@ -144,3 +146,202 @@ pub async fn import_sessions(
         results,
     })
 }
+
+// Helper struct to track import stats
+struct ImportStats {
+    results: Vec<ImportFileResult>,
+    total_sessions_imported: i32,
+    total_messages_imported: i32,
+    successful_imports: i32,
+    failed_imports: i32,
+    total_files: i32,
+}
+
+impl ImportStats {
+    fn new() -> Self {
+        Self {
+            results: Vec::new(),
+            total_sessions_imported: 0,
+            total_messages_imported: 0,
+            successful_imports: 0,
+            failed_imports: 0,
+            total_files: 0,
+        }
+    }
+}
+
+// Command to import sessions from preset providers
+#[tauri::command]
+pub async fn import_from_provider(
+    state: State<'_, Arc<Mutex<AppState>>>,
+    provider: String,
+    overwrite: bool,
+) -> Result<ImportSessionsResponse, String> {
+    log::info!(
+        "import_from_provider called with provider: {}, overwrite: {}",
+        provider,
+        overwrite
+    );
+
+    let state_guard = state.lock().await;
+    let import_service = &state_guard.import_service;
+
+    let mut stats = ImportStats::new();
+
+    // Parse provider string to Provider enum
+    let providers = match provider.to_lowercase().as_str() {
+        "all" => vec![Provider::All],
+        "claude" => vec![Provider::ClaudeCode],
+        "gemini" => vec![Provider::GeminiCLI],
+        "codex" => vec![Provider::Codex],
+        _ => return Err(format!("Unknown provider: {}", provider)),
+    };
+
+    // Expand "All" to all specific providers
+    let expanded_providers = Provider::expand_all(providers);
+
+    for prov in expanded_providers {
+        match prov {
+            Provider::All => {
+                // Should not happen due to expansion above
+                unreachable!("Provider::All should have been expanded")
+            }
+            Provider::ClaudeCode => {
+                log::info!("Importing from Claude Code directories...");
+                if let Err(e) = import_provider_directories(
+                    &ClaudeCodeConfig::create(),
+                    import_service,
+                    overwrite,
+                    &mut stats,
+                )
+                .await
+                {
+                    log::error!("Error importing Claude directories: {}", e);
+                }
+            }
+            Provider::GeminiCLI => {
+                log::info!("Importing from Gemini directories...");
+                if let Err(e) = import_provider_directories(
+                    &GeminiCliConfig::create(),
+                    import_service,
+                    overwrite,
+                    &mut stats,
+                )
+                .await
+                {
+                    log::error!("Error importing Gemini directories: {}", e);
+                }
+            }
+            Provider::Codex => {
+                log::info!("Importing from Codex directories...");
+                if let Err(e) = import_provider_directories(
+                    &CodexConfig::create(),
+                    import_service,
+                    overwrite,
+                    &mut stats,
+                )
+                .await
+                {
+                    log::error!("Error importing Codex directories: {}", e);
+                }
+            }
+            Provider::Other(name) => {
+                log::error!("Unknown provider: {}", name);
+                return Err(format!("Unknown provider: {}", name));
+            }
+        }
+    }
+
+    log::info!(
+        "Provider import completed - {} successful, {} failed, total: {} sessions, {} messages",
+        stats.successful_imports,
+        stats.failed_imports,
+        stats.total_sessions_imported,
+        stats.total_messages_imported
+    );
+
+    Ok(ImportSessionsResponse {
+        total_files: stats.total_files,
+        successful_imports: stats.successful_imports,
+        failed_imports: stats.failed_imports,
+        total_sessions_imported: stats.total_sessions_imported,
+        total_messages_imported: stats.total_messages_imported,
+        results: stats.results,
+    })
+}
+
+// Helper function to import from a provider's directories
+async fn import_provider_directories(
+    config: &retrochat::models::provider::config::ProviderConfig,
+    import_service: &retrochat::services::ImportService,
+    overwrite: bool,
+    stats: &mut ImportStats,
+) -> Result<(), String> {
+    let directories = config.get_import_directories();
+
+    if directories.is_empty() {
+        log::info!("No directories found for provider: {}", config.name);
+        return Ok(());
+    }
+
+    for dir_path in directories {
+        let path = std::path::Path::new(&dir_path);
+        if !path.exists() {
+            log::warn!("Directory not found: {}", path.display());
+            continue;
+        }
+
+        log::info!("Importing from directory: {}", path.display());
+
+        let batch_request = BatchImportRequest {
+            directory_path: dir_path.clone(),
+            providers: None,
+            project_name: None,
+            overwrite_existing: Some(overwrite),
+            recursive: Some(true),
+        };
+
+        match import_service.import_batch(batch_request).await {
+            Ok(response) => {
+                log::info!(
+                    "Successfully imported from directory '{}': {} sessions, {} messages",
+                    dir_path,
+                    response.total_sessions_imported,
+                    response.total_messages_imported
+                );
+
+                stats.total_files += response.total_files_processed;
+                stats.successful_imports += response.successful_imports;
+                stats.failed_imports += response.failed_imports;
+                stats.total_sessions_imported += response.total_sessions_imported;
+                stats.total_messages_imported += response.total_messages_imported;
+
+                // Add directory-level result
+                stats.results.push(ImportFileResult {
+                    file_path: dir_path.clone(),
+                    sessions_imported: response.total_sessions_imported,
+                    messages_imported: response.total_messages_imported,
+                    success: response.failed_imports == 0,
+                    error: if response.errors.is_empty() {
+                        None
+                    } else {
+                        Some(response.errors.join("; "))
+                    },
+                });
+            }
+            Err(e) => {
+                log::error!("Failed to import from directory '{}': {}", dir_path, e);
+                stats.failed_imports += 1;
+                stats.results.push(ImportFileResult {
+                    file_path: dir_path.clone(),
+                    sessions_imported: 0,
+                    messages_imported: 0,
+                    success: false,
+                    error: Some(e.to_string()),
+                });
+            }
+        }
+    }
+
+    Ok(())
+}

src-tauri/src/commands/session.rs

@@ -122,10 +122,8 @@ pub async fn get_session_detail(
 
     // Create a map of tool_operation_id -> tool_operation for efficient lookup
     log::debug!("Building tool operation lookup map");
-    let tool_op_by_id: std::collections::HashMap<_, _> = tool_operations
-        .into_iter()
-        .map(|op| (op.id, op))
-        .collect();
+    let tool_op_by_id: std::collections::HashMap<_, _> =
+        tool_operations.into_iter().map(|op| (op.id, op)).collect();
 
     // Create a map of message_id -> tool_operation
     log::debug!("Building message -> tool operation map");

src-tauri/src/dto.rs

@@ -370,15 +370,15 @@ impl From<retrochat::services::analytics::ToolUsageMetrics> for ToolUsageMetrics
 
 #[derive(Debug, Serialize, Deserialize)]
 pub struct HistogramRequest {
-    pub start_time: String,      // RFC3339 timestamp
-    pub end_time: String,        // RFC3339 timestamp
-    pub interval_minutes: i32,   // 5, 15, 60, 360
+    pub start_time: String,    // RFC3339 timestamp
+    pub end_time: String,      // RFC3339 timestamp
+    pub interval_minutes: i32, // 5, 15, 60, 360
 }
 
 #[derive(Debug, Serialize, Deserialize)]
 pub struct HistogramBucket {
-    pub timestamp: String,       // Bucket start time (RFC3339)
-    pub count: i32,              // Count in this bucket
+    pub timestamp: String, // Bucket start time (RFC3339)
+    pub count: i32,        // Count in this bucket
 }
 
 #[derive(Debug, Serialize, Deserialize)]

src-tauri/src/lib.rs

@@ -9,7 +9,10 @@ use commands::{
         analyze_session, cancel_analysis, create_analysis, get_analysis_result,
         get_analysis_status, list_analyses, run_analysis,
     },
-    file::{clear_opened_files, get_opened_files, handle_file_drop, import_sessions},
+    file::{
+        clear_opened_files, get_opened_files, handle_file_drop, import_from_provider,
+        import_sessions,
+    },
     histogram::{get_session_activity_histogram, get_user_message_histogram},
     session::{get_providers, get_session_detail, get_sessions, search_messages},
 };
@@ -170,6 +173,7 @@ pub async fn run() -> anyhow::Result<()> {
             get_opened_files,
             clear_opened_files,
             import_sessions,
+            import_from_provider,
             get_session_activity_histogram,
             get_user_message_histogram,
         ])