feat: Add progress bar to CLI scan command and update QUICKSTART.md

## CLI Progress Bar Enhancement

### rcompare_core/src/comparison.rs
- Add new `compare_with_vfs_and_progress()` method with progress callback support
- Accept optional `Fn(usize, usize)` closure for progress reporting
- Report (current, total) progress as files are compared
- Update existing `compare_with_vfs_and_cancel()` to use new method

### rcompare_cli/src/main.rs
- Replace spinner with progress bar during comparison phase
- Calculate total items before comparison for accurate progress tracking
- Display progress as: `[####>-----] 42/100 files (42%) [00:05] Comparing files...`
- Update progress bar in real-time as each file is processed
- Retain progress bar for scanning phase (already implemented)

## QUICKSTART.md Documentation Updates

### Added PySide6 GUI Section
- Installation instructions for Python dependencies
- Launch commands and usage guide
- Feature list: specialized diff viewers (text, image, CSV, Excel, JSON, binary)
- File operations and export capabilities

### Added C/C++ Integration (FFI) Section
- Static library build instructions for Linux/macOS/Windows
- Basic C example for parsing diffs
- CMake integration guide
- FFI features overview (parse, apply, blend, serialize)
- Documentation references

### Updated Feature Status
- Moved implemented features from "What's Next?" to "Current Features"
- Added comprehensive feature checklist with completion status
- Updated version to 0.3.0-dev
- Added roadmap reference for future enhancements
- Last updated: 2026-01-30

## User Experience Improvements

**Before (spinner)**:
```
⠋ Comparing files... [00:05]
```

**After (progress bar)**:
```
⠋ [###########>-----------] 42/100 files (42%) [00:05] Comparing files...
```

Benefits:
- Users can see exact progress (42/100 files)
- Percentage completion visible
- Better perception of remaining work
- More professional appearance

## Testing

- ✅ Builds successfully without warnings
- ✅ Core library compiles with new progress callback
- ✅ CLI compiles with progress bar implementation
- ✅ Progress bar displays during file comparison
- ✅ Backwards compatible (progress callback is optional)

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

Author: EmanueleCannizzaro

QUICKSTART.md

@@ -83,13 +83,19 @@ rcompare_cli scan /left /right -L
 
 ## Using the GUI
 
-### Launch the GUI
+RCompare provides two graphical interfaces:
+- **Slint GUI** (rcompare_gui): Native, lightweight, cross-platform
+- **PySide6 GUI** (Python frontend): Feature-rich with advanced diff viewers
+
+### Slint GUI (Native)
+
+#### Launch the GUI
 
 ```bash
 rcompare_gui
 ```
 
-### GUI Features
+#### GUI Features
 
 1. **Select Directories**: Click "Select Left..." and "Select Right..." to choose directories
 2. **Compare**: Click the "Compare" button to run the comparison
@@ -101,6 +107,126 @@ rcompare_gui
 4. **Status Bar**: Shows summary statistics at the bottom
 5. **Refresh**: Click "Refresh" to re-run the comparison
 
+### PySide6 GUI (Python Frontend)
+
+The PySide6 frontend provides advanced features including specialized diff viewers for text, images, CSV, Excel, JSON, and binary files.
+
+#### Installation
+
+```bash
+# Install Python dependencies
+pip install PySide6 Pillow openpyxl
+
+# Or use requirements file (if available)
+pip install -r frontend/requirements.txt
+```
+
+#### Launch the PySide6 GUI
+
+```bash
+# From the repository root
+python frontend/main.py
+
+# Or if installed as a package
+rcompare-pyside6
+```
+
+#### PySide6 Features
+
+1. **Directory Comparison**: Full directory tree comparison with expand/collapse
+2. **Specialized Diff Viewers**:
+   - **Text Diff**: Line-by-line comparison with syntax highlighting
+   - **Image Diff**: Side-by-side image comparison with pixel differences
+   - **CSV Diff**: Row/column comparison for CSV files
+   - **Excel Diff**: Sheet and cell-level comparison
+   - **JSON/YAML Diff**: Structural comparison with formatting
+   - **Binary Diff**: Hex viewer for binary files
+3. **File Operations**: Copy left/right with progress tracking
+4. **Export**: JSON output for automation and scripting
+5. **Settings**: Configurable comparison options and display preferences
+
+## C/C++ Integration (FFI)
+
+RCompare provides a C-compatible Foreign Function Interface (FFI) for integrating patch parsing and manipulation into C/C++ applications. This is particularly useful for KDE applications and other C++ projects that need libkomparediff2-compatible functionality.
+
+### Building the FFI Library
+
+```bash
+# Build the static library
+cargo build --package rcompare_ffi --release
+
+# Library location:
+# Linux/macOS: target/release/librcompare_ffi.a
+# Windows:     target/release/rcompare_ffi.lib
+
+# Header file:
+# rcompare_ffi/include/rcompare.h
+```
+
+### Basic C Example
+
+```c
+#include "rcompare.h"
+#include <stdio.h>
+#include <string.h>
+
+int main(void) {
+    const char* diff_text =
+        "--- a/file.txt\n"
+        "+++ b/file.txt\n"
+        "@@ -1 +1 @@\n"
+        "-old\n"
+        "+new\n";
+
+    // Parse diff
+    PatchSetHandle* handle = NULL;
+    int result = rcompare_parse_diff(
+        (const uint8_t*)diff_text,
+        strlen(diff_text),
+        &handle
+    );
+
+    if (result != 0) {
+        fprintf(stderr, "Parse failed\n");
+        return 1;
+    }
+
+    // Access metadata
+    size_t file_count = rcompare_patchset_file_count(handle);
+    printf("Files: %zu\n", file_count);
+
+    // Cleanup
+    rcompare_free_patchset(handle);
+    return 0;
+}
+```
+
+### CMake Integration
+
+```cmake
+# Add RCompare FFI to your project
+add_subdirectory(path/to/rcompare/rcompare_ffi)
+
+# Link to your target
+target_link_libraries(your_target PRIVATE rcompare)
+```
+
+### FFI Features
+
+- **Parse multiple diff formats**: Unified, context, normal, RCS, ed
+- **Auto-detect generators**: CVS, Perforce, Subversion, plain diff
+- **Patch operations**: Apply/unapply individual or all differences
+- **File blending**: Merge original file content with patch hunks
+- **Serialization**: Convert patch model back to unified diff format
+- **Memory safe**: Opaque handle pattern with proper lifetime management
+
+### Documentation
+
+For complete API reference and examples, see:
+- [rcompare_ffi/README.md](rcompare_ffi/README.md)
+- [rcompare_ffi/include/rcompare.h](rcompare_ffi/include/rcompare.h)
+- C examples: `rcompare_ffi/examples/`
+
 ## Understanding the Output
 
 ### Status Symbols (CLI)
@@ -328,20 +454,63 @@ rcompare_cli scan \
 - **Issues**: Report bugs on GitHub
 - **CLI Help**: `rcompare_cli --help`
 
+## Current Features
+
+RCompare currently provides:
+
+### Core Comparison Engine
+- ✅ BLAKE3 hashing with persistent cache
+- ✅ Parallel directory traversal
+- ✅ Gitignore pattern support
+- ✅ Cross-platform support (Linux, Windows, macOS)
+
+### Specialized Format Support
+- ✅ Text diff viewer with syntax highlighting
+- ✅ Archive comparison (ZIP, TAR, 7Z)
+- ✅ Binary hex viewer
+- ✅ Image comparison with pixel diff
+- ✅ CSV and Excel comparison
+- ✅ JSON and YAML structural diff
+- ✅ Parquet DataFrame comparison
+
+### Patch System
+- ✅ Multi-format diff parser (unified, context, normal, RCS, ed)
+- ✅ Patch apply/unapply operations
+- ✅ File blending with original content
+- ✅ C/C++ FFI layer (libkomparediff2-compatible)
+
+### User Interfaces
+- ✅ CLI with progress indicators and JSON output
+- ✅ Native Slint GUI
+- ✅ PySide6 GUI with specialized viewers
+- ✅ Copy operations (left/right)
+
 ## What's Next?
 
-Current version (0.1.0) provides basic comparison. Future enhancements:
+Future enhancements planned:
+
+### Phase 4: Performance & GUI (In Progress)
+- 🚧 Parallel hash computing (2-3x speedup)
+- 📋 Three-way merge
+- 📋 Tabs for multiple comparisons
+- 📋 Synced scrolling with diff map
+
+### Phase 5: Reporting & Workflow
+- 📋 HTML/Markdown/CSV report export
+- 📋 JUnit XML for CI integration
+- 📋 Diff statistics dashboard
+- 📋 Comparison presets (save/load)
+
+### Phase 6-7: Cloud & Advanced
+- 📋 Additional cloud providers (GCS, Azure, Dropbox)
+- 📋 Watch mode for continuous monitoring
+- 📋 Semantic diff (AST-based)
+- 📋 Plugin/extension system
 
-- Text diff viewer with syntax highlighting
-- Archive comparison (ZIP, TAR)
-- File operations (copy, move, delete)
-- Three-way merge
-- Binary hex comparison
-- Image diff visualization
-- Batch scripting support
+See [ROADMAP.md](ROADMAP.md) for detailed development timeline.
 
 ---
 
-**Version**: 0.1.0
-**Last Updated**: 2026-01-24
+**Version**: 0.3.0-dev
+**Last Updated**: 2026-01-30
 **License**: MIT OR Apache-2.0

rcompare_cli/src/main.rs

@@ -463,34 +463,64 @@ fn run_scan(
     }
 
     // Compare directories
+    // Calculate total items to compare
+    let total_items = {
+        let mut paths: std::collections::HashSet<PathBuf> = std::collections::HashSet::new();
+        for entry in &left_entries {
+            paths.insert(entry.path.clone());
+        }
+        for entry in &right_entries {
+            paths.insert(entry.path.clone());
+        }
+        paths.len() as u64
+    };
+
     let pb_compare = if show_progress {
-        let pb = ProgressBar::new_spinner();
+        let pb = ProgressBar::new(total_items);
         pb.set_style(
-            ProgressStyle::default_spinner()
-                .template("{spinner:.green} {msg} [{elapsed_precise}]")
-                .unwrap(),
+            ProgressStyle::default_bar()
+                .template("{spinner:.green} [{bar:40.cyan/blue}] {pos}/{len} files ({percent}%) [{elapsed_precise}] {msg}")
+                .unwrap()
+                .progress_chars("#>-"),
         );
         if verify_hashes {
             pb.set_message("Comparing and hashing files...");
         } else {
             pb.set_message("Comparing files...");
         }
-        pb.enable_steady_tick(std::time::Duration::from_millis(100));
         Some(pb)
     } else {
         info!("Comparing directories...");
         None
     };
 
     let comparison_engine = ComparisonEngine::new(hash_cache).with_hash_verification(verify_hashes);
-    let diff_nodes = comparison_engine.compare_with_vfs(
-        left_source.root(),
-        right_source.root(),
-        left_entries,
-        right_entries,
-        left_source.vfs(),
-        right_source.vfs(),
-    )?;
+
+    // Use progress callback if progress bar is enabled
+    let diff_nodes = if let Some(ref pb) = pb_compare {
+        let pb_clone = pb.clone();
+        comparison_engine.compare_with_vfs_and_progress(
+            left_source.root(),
+            right_source.root(),
+            left_entries,
+            right_entries,
+            left_source.vfs(),
+            right_source.vfs(),
+            None,
+            Some(move |current, _total| {
+                pb_clone.set_position(current as u64);
+            }),
+        )?
+    } else {
+        comparison_engine.compare_with_vfs(
+            left_source.root(),
+            right_source.root(),
+            left_entries,
+            right_entries,
+            left_source.vfs(),
+            right_source.vfs(),
+        )?
+    };
 
     if let Some(pb) = &pb_compare {
         pb.finish_with_message(format!(

rcompare_core/src/comparison.rs

@@ -187,6 +187,37 @@ impl ComparisonEngine {
         right_vfs: Option<&dyn Vfs>,
         cancel: Option<&AtomicBool>,
     ) -> Result<Vec<DiffNode>, RCompareError> {
+        self.compare_with_vfs_and_progress::<fn(usize, usize)>(
+            left_root,
+            right_root,
+            left_entries,
+            right_entries,
+            left_vfs,
+            right_vfs,
+            cancel,
+            None,
+        )
+    }
+
+    /// Compare directory entries with VFS support, cancellation, and progress callback
+    ///
+    /// # Arguments
+    ///
+    /// * `progress_fn` - Optional callback function that receives (current, total) progress updates
+    pub fn compare_with_vfs_and_progress<F>(
+        &self,
+        left_root: &Path,
+        right_root: &Path,
+        left_entries: Vec<FileEntry>,
+        right_entries: Vec<FileEntry>,
+        left_vfs: Option<&dyn Vfs>,
+        right_vfs: Option<&dyn Vfs>,
+        cancel: Option<&AtomicBool>,
+        progress_fn: Option<F>,
+    ) -> Result<Vec<DiffNode>, RCompareError>
+    where
+        F: Fn(usize, usize),
+    {
         info!(
             "Comparing {} left entries with {} right entries",
             left_entries.len(),
@@ -211,13 +242,20 @@ impl ComparisonEngine {
         all_paths.sort();
         all_paths.dedup();
 
-        for path in all_paths {
+        let total = all_paths.len();
+
+        for (idx, path) in all_paths.into_iter().enumerate() {
             if cancel.is_some_and(|flag| flag.load(Ordering::Relaxed)) {
                 return Err(RCompareError::Comparison(
                     "Comparison cancelled".to_string(),
                 ));
             }
 
+            // Report progress
+            if let Some(ref progress) = progress_fn {
+                progress(idx + 1, total);
+            }
+
             let left = left_map.remove(&path);
             let right = right_map.remove(&path);