support notebook recycle bin

Author: tamlok

include/vxcore/vxcore.h

@@ -80,6 +80,18 @@ VXCORE_API VxCoreError vxcore_notebook_update_config(VxCoreContextHandle context
 VXCORE_API VxCoreError vxcore_notebook_rebuild_cache(VxCoreContextHandle context,
                                                      const char *notebook_id);
 
+// ============ Recycle Bin Operations (Bundled Notebooks Only) ============
+// Get the path to the recycle bin folder.
+// Returns empty string for raw notebooks (not supported).
+VXCORE_API VxCoreError vxcore_notebook_get_recycle_bin_path(VxCoreContextHandle context,
+                                                            const char *notebook_id,
+                                                            char **out_path);
+
+// Empty the recycle bin by deleting all files and folders in it.
+// Returns VXCORE_ERR_UNSUPPORTED for raw notebooks.
+VXCORE_API VxCoreError vxcore_notebook_empty_recycle_bin(VxCoreContextHandle context,
+                                                         const char *notebook_id);
+
 // ============ Folder Operations ============
 VXCORE_API VxCoreError vxcore_folder_create(VxCoreContextHandle context, const char *notebook_id,
                                             const char *parent_path, const char *folder_name,

src/api/vxcore_notebook_api.cpp

@@ -199,3 +199,59 @@ VXCORE_API VxCoreError vxcore_notebook_rebuild_cache(VxCoreContextHandle context
     return VXCORE_ERR_UNKNOWN;
   }
 }
+
+VXCORE_API VxCoreError vxcore_notebook_get_recycle_bin_path(VxCoreContextHandle context,
+                                                            const char *notebook_id,
+                                                            char **out_path) {
+  if (!context || !notebook_id || !out_path) {
+    return VXCORE_ERR_NULL_POINTER;
+  }
+
+  auto *ctx = reinterpret_cast<vxcore::VxCoreContext *>(context);
+
+  try {
+    auto *notebook = ctx->notebook_manager->GetNotebook(notebook_id);
+    if (!notebook) {
+      ctx->last_error = "Notebook not found";
+      return VXCORE_ERR_NOT_FOUND;
+    }
+
+    std::string path = notebook->GetRecycleBinPath();
+    char *path_copy = vxcore_strdup(path.c_str());
+    if (!path_copy) {
+      return VXCORE_ERR_OUT_OF_MEMORY;
+    }
+
+    *out_path = path_copy;
+    return VXCORE_OK;
+  } catch (...) {
+    ctx->last_error = "Unknown error getting recycle bin path";
+    return VXCORE_ERR_UNKNOWN;
+  }
+}
+
+VXCORE_API VxCoreError vxcore_notebook_empty_recycle_bin(VxCoreContextHandle context,
+                                                         const char *notebook_id) {
+  if (!context || !notebook_id) {
+    return VXCORE_ERR_NULL_POINTER;
+  }
+
+  auto *ctx = reinterpret_cast<vxcore::VxCoreContext *>(context);
+
+  try {
+    auto *notebook = ctx->notebook_manager->GetNotebook(notebook_id);
+    if (!notebook) {
+      ctx->last_error = "Notebook not found";
+      return VXCORE_ERR_NOT_FOUND;
+    }
+
+    VxCoreError err = notebook->EmptyRecycleBin();
+    if (err != VXCORE_OK) {
+      ctx->last_error = "Failed to empty recycle bin";
+    }
+    return err;
+  } catch (...) {
+    ctx->last_error = "Unknown error emptying recycle bin";
+    return VXCORE_ERR_UNKNOWN;
+  }
+}

src/core/bundled_folder_manager.cpp

@@ -382,10 +382,18 @@ VxCoreError BundledFolderManager::DeleteFolder(const std::string &folder_path) {
   }
 
   try {
+    // Move content folder to recycle bin instead of permanent delete
+    VxCoreError move_error = MoveToRecycleBin(fs::path(content_path));
+    if (move_error != VXCORE_OK) {
+      VXCORE_LOG_WARN("Failed to move folder to recycle bin, falling back to delete: %s",
+                      content_path.c_str());
+      fs::remove_all(content_path);
+    }
+
+    // Always permanently delete the config folder (vx.json metadata)
     if (fs::exists(config_path)) {
       fs::remove_all(fs::path(config_path).parent_path());
     }
-    fs::remove_all(content_path);
 
     // Write-through to MetadataStore
     if (auto *store = notebook_->GetMetadataStore(); store && !folder_id.empty()) {
@@ -824,7 +832,14 @@ VxCoreError BundledFolderManager::DeleteFile(const std::string &file_path) {
   try {
     std::string content_path = GetContentPath(folder_path);
     fs::path fs_file_path = fs::path(content_path) / file_name;
-    fs::remove(fs_file_path);
+
+    // Move to recycle bin instead of permanent delete
+    VxCoreError move_error = MoveToRecycleBin(fs_file_path);
+    if (move_error != VXCORE_OK) {
+      VXCORE_LOG_WARN("Failed to move file to recycle bin, falling back to delete: %s",
+                      fs_file_path.string().c_str());
+      fs::remove(fs_file_path);
+    }
 
     // Write-through to MetadataStore
     if (auto *store = notebook_->GetMetadataStore(); !file_id.empty()) {
@@ -1541,4 +1556,80 @@ void BundledFolderManager::SyncFolderToStore(const std::string &folder_path,
                    config.id.c_str(), folder_path.c_str());
 }
 
+
+std::string BundledFolderManager::GetRecycleBinPath() const {
+  return ConcatenatePaths(notebook_->GetMetadataFolder(), "recycle_bin");
+}
+
+std::string BundledFolderManager::GenerateUniqueRecycleBinName(const std::string &name) const {
+  fs::path recycle_bin_path(GetRecycleBinPath());
+  fs::path dest_path = recycle_bin_path / name;
+
+  if (!fs::exists(dest_path)) {
+    return name;
+  }
+
+  // Extract base name and extension
+  std::string base_name = name;
+  std::string extension;
+  size_t dot_pos = name.find_last_of('.');
+  if (dot_pos != std::string::npos && dot_pos > 0) {
+    base_name = name.substr(0, dot_pos);
+    extension = name.substr(dot_pos);
+  }
+
+  // Try _1, _2, _3, etc. until we find a unique name
+  int suffix = 1;
+  while (true) {
+    std::string new_name = base_name + "_" + std::to_string(suffix) + extension;
+    dest_path = recycle_bin_path / new_name;
+    if (!fs::exists(dest_path)) {
+      return new_name;
+    }
+    ++suffix;
+    if (suffix > 10000) {
+      // Safety limit to prevent infinite loop
+      VXCORE_LOG_ERROR("GenerateUniqueRecycleBinName: Too many conflicts for %s", name.c_str());
+      return base_name + "_" + std::to_string(GetCurrentTimestampMillis()) + extension;
+    }
+  }
+}
+
+VxCoreError BundledFolderManager::MoveToRecycleBin(const std::filesystem::path &source_path) {
+  if (!fs::exists(source_path)) {
+    VXCORE_LOG_WARN("MoveToRecycleBin: Source does not exist: %s", source_path.string().c_str());
+    return VXCORE_ERR_NOT_FOUND;
+  }
+
+  fs::path recycle_bin_path(GetRecycleBinPath());
+
+  // Ensure recycle bin directory exists
+  try {
+    if (!fs::exists(recycle_bin_path)) {
+      fs::create_directories(recycle_bin_path);
+      VXCORE_LOG_INFO("MoveToRecycleBin: Created recycle bin at %s",
+                      recycle_bin_path.string().c_str());
+    }
+  } catch (const std::exception &e) {
+    VXCORE_LOG_ERROR("MoveToRecycleBin: Failed to create recycle bin: %s", e.what());
+    return VXCORE_ERR_IO;
+  }
+
+  // Generate unique name in recycle bin
+  std::string original_name = source_path.filename().string();
+  std::string unique_name = GenerateUniqueRecycleBinName(original_name);
+  fs::path dest_path = recycle_bin_path / unique_name;
+
+  // Move the file/folder to recycle bin
+  try {
+    fs::rename(source_path, dest_path);
+    VXCORE_LOG_INFO("MoveToRecycleBin: Moved %s to %s", source_path.string().c_str(),
+                    dest_path.string().c_str());
+    return VXCORE_OK;
+  } catch (const std::exception &e) {
+    VXCORE_LOG_ERROR("MoveToRecycleBin: Failed to move %s: %s", source_path.string().c_str(),
+                     e.what());
+    return VXCORE_ERR_IO;
+  }
+}
 }  // namespace vxcore

src/core/bundled_folder_manager.h

@@ -2,6 +2,7 @@
 #define VXCORE_BUNDLED_FOLDER_MANAGER_H
 
 #include <map>
+#include <filesystem>
 #include <memory>
 #include <string>
 
@@ -85,6 +86,9 @@ class BundledFolderManager : public FolderManager {
   // Returns VXCORE_OK on success
   VxCoreError SyncMetadataStoreFromConfigs();
 
+  // Returns the path to the recycle bin folder
+  std::string GetRecycleBinPath() const;
+
  private:
   VxCoreError GetFolderConfig(const std::string &folder_path, FolderConfig **out_config,
                               const std::string *parent_id = nullptr);
@@ -109,6 +113,9 @@ class BundledFolderManager : public FolderManager {
   // Get the parent folder's ID (UUID) for a given folder path
   std::string GetParentFolderId(const std::string &folder_path);
 
+  // Recycle bin helpers
+  std::string GenerateUniqueRecycleBinName(const std::string &name) const;
+  VxCoreError MoveToRecycleBin(const std::filesystem::path &source_path);
   std::map<std::string, std::unique_ptr<FolderConfig>> config_cache_;
 };
 

src/core/bundled_notebook.cpp

@@ -186,4 +186,31 @@ VxCoreError BundledNotebook::RebuildCache() {
   return bundled_folder_manager->SyncMetadataStoreFromConfigs();
 }
 
+std::string BundledNotebook::GetRecycleBinPath() const {
+  auto *bundled_folder_manager = dynamic_cast<BundledFolderManager *>(folder_manager_.get());
+  if (!bundled_folder_manager) {
+    VXCORE_LOG_ERROR("GetRecycleBinPath: folder_manager is not BundledFolderManager");
+    return "";
+  }
+  return bundled_folder_manager->GetRecycleBinPath();
+}
+
+VxCoreError BundledNotebook::EmptyRecycleBin() {
+  std::string recycle_bin_path = GetRecycleBinPath();
+  try {
+    std::filesystem::path rb_path(recycle_bin_path);
+    if (!std::filesystem::exists(rb_path)) {
+      return VXCORE_OK;  // Nothing to empty
+    }
+    for (const auto &entry : std::filesystem::directory_iterator(rb_path)) {
+      std::filesystem::remove_all(entry.path());
+    }
+    VXCORE_LOG_INFO("EmptyRecycleBin: Cleared recycle bin at %s", recycle_bin_path.c_str());
+    return VXCORE_OK;
+  } catch (const std::exception &e) {
+    VXCORE_LOG_ERROR("EmptyRecycleBin: Failed to empty recycle bin: %s", e.what());
+    return VXCORE_ERR_IO;
+  }
+}
+
 }  // namespace vxcore

src/core/bundled_notebook.h

@@ -19,6 +19,9 @@ class BundledNotebook : public Notebook {
   VxCoreError UpdateConfig(const NotebookConfig &config) override;
   VxCoreError RebuildCache() override;
 
+  std::string GetRecycleBinPath() const override;
+  VxCoreError EmptyRecycleBin() override;
+
  private:
   BundledNotebook(const std::string &local_data_folder, const std::string &root_folder);
 

src/core/notebook.h

@@ -67,6 +67,13 @@ class Notebook {
   std::string GetLocalDataFolder() const;
   virtual std::string GetMetadataFolder() const = 0;
 
+  // Recycle bin operations (bundled notebooks only)
+  // Returns the path to the recycle bin folder, or empty string if not supported.
+  virtual std::string GetRecycleBinPath() const = 0;
+  // Empties the recycle bin by deleting all files and folders in it.
+  // Returns VXCORE_OK on success, VXCORE_ERR_NOT_SUPPORTED for raw notebooks.
+  virtual VxCoreError EmptyRecycleBin() = 0;
+
   FolderManager *GetFolderManager() { return folder_manager_.get(); }
   MetadataStore *GetMetadataStore() { return metadata_store_.get(); }
 

src/core/raw_notebook.cpp

@@ -154,4 +154,14 @@ VxCoreError RawNotebook::RebuildCache() {
   return VXCORE_OK;
 }
 
+std::string RawNotebook::GetRecycleBinPath() const {
+  // Raw notebooks do not support recycle bin
+  return "";
+}
+
+VxCoreError RawNotebook::EmptyRecycleBin() {
+  // Raw notebooks do not support recycle bin
+  return VXCORE_ERR_UNSUPPORTED;
+}
+
 }  // namespace vxcore

src/core/raw_notebook.h

@@ -17,6 +17,9 @@ class RawNotebook : public Notebook {
   VxCoreError UpdateConfig(const NotebookConfig &config) override;
   VxCoreError RebuildCache() override;
 
+  std::string GetRecycleBinPath() const override;
+  VxCoreError EmptyRecycleBin() override;
+
  private:
   RawNotebook(const std::string &local_data_folder, const std::string &root_folder);