Migrate file tree creation to Rust backend (#6)

* feat(filetree): move file tree generation logic to Rust backend

Migrates the recursive file tree building logic from the TypeScript frontend to the Rust backend to improve performance, especially for large directories.

- Implements `build_file_tree` Tauri command in Rust.
- Adds Desktop implementation using `std::fs` and `spawn_blocking`.
- Adds Android implementation using `tauri-plugin-android-fs` and `urlencoding`.
- Updates frontend `builder.ts` to invoke the Rust command.
- Preserves existing filtering logic (markdown files only, ignore hidden dirs).

* perf: optimize file tree building and sorting in Rust

- Move sorting logic inside `spawn_blocking` to avoid blocking the main thread on large directories.
- Fix compiler warnings (unused imports/variables).
- Ensure correct recursion and sorting on both Desktop and Android.
- Refactor argument names to avoid unused variable warnings across platforms.

* feat(filetree): move generation and sorting to Rust backend

Migrates file tree logic to Rust to improve performance and prevent UI freezes.
- Implements `build_file_tree` and `sort_file_tree` Tauri commands in `src-tauri/src/lib.rs`.
- Uses `spawn_blocking` to offload heavy operations from the main thread.
- Ensures compatibility with Android FS plugin (fixing compilation issues) and Desktop `std::fs`.
- Updates frontend to invoke Rust commands and safely handle auto-sorting in `$effect` without infinite loops.
- Adds `urlencoding` dependency for Android path handling.
- Cleans up deprecated JS logic.

* fix: don't use rust sort function for subsequent sorts bcuz of latency and less flexibility

so, calling rust sort function everytime for subsequent sorting seems to
have incresed latency.
also on rename or any file tree changes, the sorting was commented out.

* refac: remove unwanted legacy functions

* fix(error): show a toast error if file tree building fails

* Update apps/app/src-tauri/src/lib.rs

Co-authored-by: Copilot <175728472+Copilot@users.noreply.github.com>

* Update apps/app/src-tauri/src/lib.rs

Co-authored-by: Copilot <175728472+Copilot@users.noreply.github.com>

* Update apps/app/src-tauri/src/lib.rs

Co-authored-by: Copilot <175728472+Copilot@users.noreply.github.com>

* fix: use inline type modifier for FileNode import for consistency

Co-authored-by: Keshav-writes-code <95571677+Keshav-writes-code@users.noreply.github.com>

* feat: implement natural/numeric sorting using natord crate

Co-authored-by: Keshav-writes-code <95571677+Keshav-writes-code@users.noreply.github.com>

* fix: add aria label to icon based buttons

* fix(performace): make subtree sorting happen only on rename operation not in the $effect block which slows down speed

* fix: add sorting when new element gets inserted

* refac: remove debugging statementsa

* refac: remove unwanted vairables

* chore: update deps

* chore: update deps

* fix(ui_webkit): fix strange behaviour where a previously selected item stays selected after mutate the name and path of a node

---------

Co-authored-by: google-labs-jules[bot] <161369871+google-labs-jules[bot]@users.noreply.github.com>
Co-authored-by: keshav-writes-code <dhimankeshav201@gmail.com>
Co-authored-by: Keshav <95571677+Keshav-writes-code@users.noreply.github.com>
Co-authored-by: Copilot <175728472+Copilot@users.noreply.github.com>
Co-authored-by: copilot-swe-agent[bot] <198982749+Copilot@users.noreply.github.com>

Author: 4 people

apps/app/src-tauri/Cargo.lock

@@ -30,3 +30,5 @@ tauri-plugin-fs = "2"
 tauri-plugin-store = "2"
 tauri-plugin-dialog = "2"
 tauri-plugin-os = "2"
+urlencoding = "2"
+futures = "0.3.31"

apps/app/src-tauri/Cargo.toml

@@ -1,3 +1,194 @@
+use serde::{Deserialize, Serialize};
+
+#[derive(Serialize, Deserialize, Clone)]
+pub struct FileNode {
+    pub name: String,
+    pub path: String,
+    pub is_directory: bool,
+    pub children: Vec<FileNode>,
+}
+
+fn sort_nodes(nodes: &mut Vec<FileNode>) {
+    nodes.sort_by(|a, b| {
+        if a.is_directory != b.is_directory {
+            return if a.is_directory {
+                std::cmp::Ordering::Less
+            } else {
+                std::cmp::Ordering::Greater
+            };
+        }
+        a.name.to_lowercase().cmp(&b.name.to_lowercase())
+    });
+
+    for node in nodes {
+        if !node.children.is_empty() {
+            sort_nodes(&mut node.children);
+        }
+    }
+}
+
+#[cfg(not(target_os = "android"))]
+fn build_tree_recursive_desktop(path_str: &str) -> std::io::Result<Vec<FileNode>> {
+    use std::fs;
+    let mut nodes = Vec::new();
+    let entries = fs::read_dir(path_str)?;
+
+    for entry in entries {
+        if let Ok(entry) = entry {
+            if let Ok(metadata) = entry.metadata() {
+                let file_name = entry.file_name().to_string_lossy().to_string();
+
+                let is_directory = metadata.is_dir();
+                let starts_with_dot = file_name.starts_with('.');
+                let ends_with_md = file_name.ends_with(".md");
+
+                if (is_directory && !starts_with_dot) || ends_with_md {
+                    let path = entry.path().to_string_lossy().to_string();
+                    let mut children = Vec::new();
+
+                    if is_directory {
+                        if let Ok(sub_children) = build_tree_recursive_desktop(&path) {
+                            children = sub_children;
+                        }
+                    }
+
+                    nodes.push(FileNode {
+                        name: file_name.trim_end_matches(".md").to_string(),
+                        path,
+                        is_directory,
+                        children,
+                    });
+                }
+            }
+        }
+    }
+    Ok(nodes)
+}
+
+#[cfg(target_os = "android")]
+fn build_tree_recursive_android(
+    app: tauri::AppHandle,
+    path: String,
+    document_top_tree_uri: Option<String>,
+) -> std::pin::Pin<Box<dyn std::future::Future<Output = Result<Vec<FileNode>, String>> + Send>> {
+    Box::pin(async move {
+        use tauri_plugin_android_fs::AndroidFsExt;
+        use tauri_plugin_android_fs::FileUri;
+        use tauri_plugin_android_fs::EntryOptions;
+        use futures::future::join_all;
+
+        let api = app.android_fs();
+
+        let json_obj = serde_json::json!({
+            "uri": path,
+            "documentTopTreeUri": document_top_tree_uri
+        });
+        let file_uri = FileUri::from_json_str(&json_obj.to_string())
+            .map_err(|e| format!("Failed to create FileUri: {}", e))?;
+
+        let options = EntryOptions {
+            uri: false,
+            name: true,
+            last_modified: false,
+            len: false,
+            mime_type: false,
+        };
+
+        let entries = api.read_dir_with_options(&file_uri, options)
+            .map_err(|e| e.to_string())?;
+
+        let mut futures = Vec::new();
+        let mut nodes = Vec::new();
+
+        for entry in entries {
+            let is_directory = entry.is_dir();
+            let name_opt = entry.name();
+
+            if let Some(name_str) = name_opt {
+                let name = name_str.to_string();
+                let starts_with_dot = name.starts_with('.');
+                let ends_with_md = name.ends_with(".md");
+
+                if (is_directory && !starts_with_dot) || ends_with_md {
+                    let path_uri = format!("{}%2F{}", path, urlencoding::encode(&name));
+
+                    if is_directory {
+                        let app_clone = app.clone();
+                        let path_clone = path_uri.clone();
+                        let doc_uri_clone = document_top_tree_uri.clone();
+                        let name_clone = name.clone();
+
+                        futures.push(async move {
+                             let children_res = build_tree_recursive_android(
+                                app_clone,
+                                path_clone.clone(),
+                                doc_uri_clone
+                            ).await;
+
+                            match children_res {
+                                Ok(children) => Some(FileNode {
+                                    name: name_clone.trim_end_matches(".md").to_string(),
+                                    path: path_clone,
+                                    is_directory: true,
+                                    children,
+                                }),
+                                Err(_) => None
+                            }
+                        });
+                    } else {
+                        nodes.push(FileNode {
+                            name: name.trim_end_matches(".md").to_string(),
+                            path: path_uri,
+                            is_directory: false,
+                            children: vec![],
+                        });
+                    }
+                }
+            }
+        }
+
+        let results = join_all(futures).await;
+        for res in results {
+            if let Some(node) = res {
+                nodes.push(node);
+            }
+        }
+
+        Ok(nodes)
+    })
+}
+
+#[tauri::command]
+async fn build_file_tree(
+    app: tauri::AppHandle,
+    path: String,
+    document_top_tree_uri: Option<String>,
+) -> Result<Vec<FileNode>, String> {
+    let nodes;
+
+    #[cfg(target_os = "android")]
+    {
+        let mut unsorted_nodes = build_tree_recursive_android(app, path, document_top_tree_uri).await?;
+        sort_nodes(&mut unsorted_nodes);
+        nodes = unsorted_nodes;
+    }
+
+    #[cfg(not(target_os = "android"))]
+    {
+        // Suppress unused variable warnings on desktop
+        let _ = app;
+        let _ = document_top_tree_uri;
+        nodes = tauri::async_runtime::spawn_blocking(move || {
+            let mut n = build_tree_recursive_desktop(&path)?;
+            sort_nodes(&mut n);
+            Ok(n)
+        }).await.map_err(|e| e.to_string())?
+          .map_err(|e: std::io::Error| e.to_string())?;
+    }
+
+    Ok(nodes)
+}
+
 #[cfg_attr(mobile, tauri::mobile_entry_point)]
 pub fn run() {
     tauri::Builder::default()
@@ -6,6 +197,7 @@ pub fn run() {
         .plugin(tauri_plugin_store::Builder::new().build())
         .plugin(tauri_plugin_fs::init())
         .plugin(tauri_plugin_android_fs::init())
+        .invoke_handler(tauri::generate_handler![build_file_tree])
         .setup(|app| {
             if cfg!(debug_assertions) {
                 app.handle().plugin(

apps/app/src-tauri/src/lib.rs

@@ -24,6 +24,7 @@
   $effect(() => {
     if (file_tree) sort_file_tree(file_tree);
   });
+
   let collapsed_state: boolean = $state(true);
   $effect(() => {
     if (!root_path) return;

apps/app/src/components/sidebar/file_manager/index.svelte

@@ -257,7 +257,7 @@
     ondragstart={(e) => handle_drag_start(e, node)}
     ondragend={reset_dnd}
     oncontextmenu={(e) => handle_node_right_click(e, node)}
-    class="{opened_filenode?.path === node.path ? 'bg-base-content/10' : ''} 
+    class="{opened_filenode?.path === node.path ? 'bg-base-content/10' : ''}
       {dragged_node?.path === node.path ? 'opacity-50' : ''}
       py-0.75 w-full hover:text-[color-mix(in_srgb,var(--color-base-content)_85%,black)] truncate block"
     onclick={(e) => {