feat: Add dirty check and caching for analytics requests (#62)

Implements session-level dirty checking to prevent redundant analysis when sessions haven't changed. When a session is unchanged since the last completed analysis, the system now:
- Returns cached results automatically with informative messages
- Provides guidance on how to force new analysis if needed
- Bypasses dirty check when custom prompts are provided

Includes comprehensive test coverage for dirty check behavior and custom prompt bypass scenarios.

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

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

Author: sanggggg

src/cli/analytics.rs

@@ -114,14 +114,66 @@ async fn execute_analysis_for_session(
     println!("Starting analysis for session: {session_id}");
 
     // Create analysis request
-    let request = service
+    let request = match service
         .create_analysis_request(
             session_id.clone(),
             None, // created_by
-            custom_prompt,
+            custom_prompt.clone(),
         )
         .await
-        .map_err(|e| anyhow::anyhow!("Failed to create analysis request: {e}"))?;
+    {
+        Ok(request) => request,
+        Err(e) => {
+            let error_msg = e.to_string();
+            // Check if this is a dirty check error (session unchanged)
+            if error_msg.contains("has not been modified since last analysis") {
+                println!("ℹ Session has not changed since last analysis");
+                println!("Retrieving cached results...\n");
+
+                // Find the latest completed request
+                let requests = service
+                    .list_analyses(Some(session_id.clone()), None)
+                    .await
+                    .map_err(|e| anyhow::anyhow!("Failed to list analyses: {e}"))?;
+
+                if let Some(latest_request) = requests
+                    .iter()
+                    .filter(|r| matches!(r.status, OperationStatus::Completed))
+                    .max_by_key(|r| r.completed_at.as_ref())
+                {
+                    // Determine output format
+                    let output_format = if plain {
+                        OutputFormat::Plain
+                    } else {
+                        OutputFormat::parse(&format)
+                    };
+
+                    // Get and display cached results
+                    if let Some(analysis) = service
+                        .get_analysis_result(latest_request.id.clone())
+                        .await
+                        .map_err(|e| anyhow::anyhow!("Failed to get cached analysis: {e}"))?
+                    {
+                        print_unified_analysis(&analysis, output_format).await?;
+                        println!(
+                            "\n✓ Showing cached results from: {}",
+                            latest_request
+                                .completed_at
+                                .map(|dt| dt.to_rfc3339())
+                                .unwrap_or_else(|| "unknown".to_string())
+                        );
+                        println!("  To force new analysis, use: --custom-prompt \"your prompt\"");
+                        return Ok(());
+                    }
+                }
+
+                return Err(anyhow::anyhow!("No cached results found"));
+            }
+
+            // Other errors, propagate them
+            return Err(anyhow::anyhow!("Failed to create analysis request: {e}"));
+        }
+    };
 
     if background {
         println!("Analysis request created: {}", request.id);

src/services/analytics_request_service.rs

@@ -1,6 +1,8 @@
 use std::sync::Arc;
 
-use crate::database::{AnalyticsRepository, AnalyticsRequestRepository, DatabaseManager};
+use crate::database::{
+    AnalyticsRepository, AnalyticsRequestRepository, ChatSessionRepository, DatabaseManager,
+};
 use crate::models::{Analytics, AnalyticsRequest, OperationStatus};
 use crate::services::analytics_service::AnalyticsService;
 use crate::services::google_ai::GoogleAiClient;
@@ -32,7 +34,7 @@ impl AnalyticsRequestService {
     ) -> Result<AnalyticsRequest, Box<dyn std::error::Error + Send + Sync>> {
         // Check if there's already an active request for this session
         let existing_requests = self.request_repo.find_by_session_id(&session_id).await?;
-        for existing_request in existing_requests {
+        for existing_request in &existing_requests {
             match existing_request.status {
                 OperationStatus::Pending | OperationStatus::Running => {
                     return Err(format!(
@@ -44,6 +46,42 @@ impl AnalyticsRequestService {
             }
         }
 
+        // Dirty check: Check if session has been updated since last completed analysis
+        if custom_prompt.is_none() {
+            // Only perform dirty check if there's no custom prompt
+            // (custom prompts should always create new requests)
+            if let Some(latest_completed) = existing_requests
+                .iter()
+                .filter(|r| matches!(r.status, OperationStatus::Completed))
+                .max_by_key(|r| r.completed_at.as_ref())
+            {
+                // Get the session to check its updated_at timestamp
+                let session_repo = ChatSessionRepository::new(&self.db_manager);
+                if let Ok(Some(session)) = session_repo
+                    .get_by_id(
+                        &uuid::Uuid::parse_str(&session_id)
+                            .map_err(|e| format!("Invalid session ID: {e}"))?,
+                    )
+                    .await
+                {
+                    if let Some(completed_at) = latest_completed.completed_at {
+                        // If session hasn't been updated since the last analysis, return existing request
+                        if session.updated_at <= completed_at {
+                            tracing::info!(
+                                session_id = %session_id,
+                                last_analysis = %completed_at,
+                                session_updated = %session.updated_at,
+                                "Session unchanged since last analysis - using cached results"
+                            );
+                            return Err(format!(
+                                "Session {session_id} has not been modified since last analysis (completed at {completed_at}). Use 'retrochat analytics show {session_id}' to view cached results, or provide --custom-prompt to force new analysis."
+                            ).into());
+                        }
+                    }
+                }
+            }
+        }
+
         let request = AnalyticsRequest::new(session_id, created_by, custom_prompt);
 
         self.request_repo.create(&request).await?;
@@ -372,4 +410,115 @@ mod tests {
         assert_eq!(status.id, request.id);
         assert_eq!(status.status, OperationStatus::Pending);
     }
+
+    #[tokio::test]
+    async fn test_dirty_check_prevents_duplicate_analysis() {
+        let database = Database::new_in_memory().await.unwrap();
+        database.initialize().await.unwrap();
+
+        // Create a test project
+        let project_repo = crate::database::ProjectRepository::new(&database.manager);
+        let test_project = crate::models::Project::new("test_project3".to_string());
+        project_repo.create(&test_project).await.unwrap();
+
+        // Create a test session
+        let session_repo = crate::database::ChatSessionRepository::new(&database.manager);
+        let test_session = crate::models::ChatSession::new(
+            crate::models::Provider::ClaudeCode,
+            "/test/chat3.jsonl".to_string(),
+            "test_hash3".to_string(),
+            chrono::Utc::now(),
+        )
+        .with_project("test_project3".to_string());
+        session_repo.create(&test_session).await.unwrap();
+
+        let service = AnalyticsRequestService::new(
+            Arc::new(database.manager.clone()),
+            GoogleAiClient::new(GoogleAiConfig::new("test-api-key".to_string())).unwrap(),
+        );
+
+        let session_id = test_session.id.to_string();
+
+        // Create first request
+        let first_request = service
+            .create_analysis_request(session_id.clone(), None, None)
+            .await
+            .unwrap();
+
+        // Mark it as completed
+        let mut completed_request = first_request.clone();
+        completed_request.mark_completed();
+        let request_repo = AnalyticsRequestRepository::new(Arc::new(database.manager.clone()));
+        request_repo.update(&completed_request).await.unwrap();
+
+        // Wait a bit to ensure timestamp difference
+        tokio::time::sleep(tokio::time::Duration::from_millis(10)).await;
+
+        // Try to create second request without updating the session
+        // This should fail with dirty check error
+        let result = service
+            .create_analysis_request(session_id.clone(), None, None)
+            .await;
+
+        assert!(result.is_err());
+        let error_msg = result.unwrap_err().to_string();
+        assert!(error_msg.contains("has not been modified since last analysis"));
+    }
+
+    #[tokio::test]
+    async fn test_dirty_check_bypassed_with_custom_prompt() {
+        let database = Database::new_in_memory().await.unwrap();
+        database.initialize().await.unwrap();
+
+        // Create a test project
+        let project_repo = crate::database::ProjectRepository::new(&database.manager);
+        let test_project = crate::models::Project::new("test_project4".to_string());
+        project_repo.create(&test_project).await.unwrap();
+
+        // Create a test session
+        let session_repo = crate::database::ChatSessionRepository::new(&database.manager);
+        let test_session = crate::models::ChatSession::new(
+            crate::models::Provider::ClaudeCode,
+            "/test/chat4.jsonl".to_string(),
+            "test_hash4".to_string(),
+            chrono::Utc::now(),
+        )
+        .with_project("test_project4".to_string());
+        session_repo.create(&test_session).await.unwrap();
+
+        let service = AnalyticsRequestService::new(
+            Arc::new(database.manager.clone()),
+            GoogleAiClient::new(GoogleAiConfig::new("test-api-key".to_string())).unwrap(),
+        );
+
+        let session_id = test_session.id.to_string();
+
+        // Create first request
+        let first_request = service
+            .create_analysis_request(session_id.clone(), None, None)
+            .await
+            .unwrap();
+
+        // Mark it as completed
+        let mut completed_request = first_request.clone();
+        completed_request.mark_completed();
+        let request_repo = AnalyticsRequestRepository::new(Arc::new(database.manager.clone()));
+        request_repo.update(&completed_request).await.unwrap();
+
+        // Create second request with custom prompt (should bypass dirty check)
+        let result = service
+            .create_analysis_request(
+                session_id.clone(),
+                None,
+                Some("Custom analysis prompt".to_string()),
+            )
+            .await;
+
+        assert!(result.is_ok());
+        let second_request = result.unwrap();
+        assert_eq!(
+            second_request.custom_prompt,
+            Some("Custom analysis prompt".to_string())
+        );
+    }
 }