feat(db): sync tags from NotebookConfig to MetadataStore on open

- Add SyncTagsToStore() to sync tag definitions from config to DB
- Extract NotebookDb class for notebook metadata operations
- Add notebook_metadata table for key-value storage
- Reuse tag_depth map for orphan detection (avoid redundant set)
- Add test_tag_sync for tag synchronization verification

Author: tamlok

.gitignore

@@ -48,3 +48,5 @@ compile_commands.json
 test_notebook
 
 .cache
+
+.sisyphus

src/CMakeLists.txt

@@ -27,6 +27,7 @@ set(VXCORE_SOURCES
     db/db_manager.cpp
     db/file_db.cpp
     db/tag_db.cpp
+    db/notebook_db.cpp
     db/sync_manager.cpp
     db/sqlite_metadata_store.cpp
     search/search_manager.cpp

src/core/bundled_notebook.cpp

@@ -64,6 +64,13 @@ VxCoreError BundledNotebook::InitOnCreation() {
     return err;
   }
 
+  // Sync tags from NotebookConfig to MetadataStore
+  err = SyncTagsToMetadataStore();
+  if (err != VXCORE_OK) {
+    VXCORE_LOG_WARN("Tag sync failed on creation: root=%s, error=%d", root_folder_.c_str(), err);
+    // Continue anyway - tags will be synced on next open
+  }
+
   err = folder_manager_->InitOnCreation();
   if (err != VXCORE_OK) {
     VXCORE_LOG_ERROR("Failed to initialize bundled notebook folder manager: root=%s, error=%d",
@@ -104,7 +111,14 @@ VxCoreError BundledNotebook::Open(const std::string &local_data_folder,
     return err;
   }
 
-  // Note: We do NOT sync MetadataStore from config files here.
+  // Sync tags from NotebookConfig to MetadataStore if needed
+  err = notebook->SyncTagsToMetadataStore();
+  if (err != VXCORE_OK) {
+    VXCORE_LOG_WARN("Tag sync failed on open: root=%s, error=%d", root_folder.c_str(), err);
+    // Continue anyway - tags will be synced on next open or RebuildCache
+  }
+
+  // Note: We do NOT sync folder/file MetadataStore from config files here.
   // The cache uses lazy sync - data is loaded on demand when accessed.
   // Users can call RebuildCache() if they need a full refresh.
 

src/core/metadata_store.h

@@ -217,6 +217,11 @@ class MetadataStore {
   virtual void IterateAllFiles(
       std::function<bool(const std::string&, const StoreFileRecord&)> callback) = 0;
 
+  // --- Notebook Metadata ---
+  // Key-value store for notebook-level metadata (e.g., tags_synced_utc)
+  virtual std::optional<std::string> GetNotebookMetadata(const std::string& key) = 0;
+  virtual bool SetNotebookMetadata(const std::string& key, const std::string& value) = 0;
+
   // --- Error Handling ---
 
   // Returns the last error message

src/core/notebook.cpp

@@ -3,6 +3,7 @@
 #include <vxcore/vxcore_types.h>
 
 #include <algorithm>
+#include <unordered_map>
 
 #include "db/sqlite_metadata_store.h"
 #include "folder_manager.h"
@@ -45,7 +46,8 @@ nlohmann::json TagNode::ToJson() const {
 NotebookConfig::NotebookConfig()
     : assets_folder("vx_assets"),
       attachments_folder("vx_attachments"),
-      metadata(nlohmann::json::object()) {}
+      metadata(nlohmann::json::object()),
+      tags_modified_utc(0) {}
 
 NotebookConfig NotebookConfig::FromJson(const nlohmann::json &json) {
   NotebookConfig config;
@@ -72,6 +74,9 @@ NotebookConfig NotebookConfig::FromJson(const nlohmann::json &json) {
       config.tags.push_back(TagNode::FromJson(tag_json));
     }
   }
+  if (json.contains("tagsModifiedUtc") && json["tagsModifiedUtc"].is_number_integer()) {
+    config.tags_modified_utc = json["tagsModifiedUtc"].get<int64_t>();
+  }
   return config;
 }
 
@@ -88,6 +93,7 @@ nlohmann::json NotebookConfig::ToJson() const {
     tags_array.push_back(tag.ToJson());
   }
   json["tags"] = std::move(tags_array);
+  json["tagsModifiedUtc"] = tags_modified_utc;
   return json;
 }
 
@@ -155,6 +161,136 @@ VxCoreError Notebook::InitMetadataStore() {
   return VXCORE_OK;
 }
 
+VxCoreError Notebook::SyncTagsToMetadataStore() {
+  if (!metadata_store_ || !metadata_store_->IsOpen()) {
+    return VXCORE_ERR_INVALID_STATE;
+  }
+
+  // 1. Get tags_synced_utc from DB
+  int64_t tags_synced_utc = 0;
+  auto synced_str = metadata_store_->GetNotebookMetadata("tags_synced_utc");
+  if (synced_str.has_value()) {
+    try {
+      tags_synced_utc = std::stoll(synced_str.value());
+    } catch (...) {
+      tags_synced_utc = 0;
+    }
+  }
+
+  // 2. Check if sync needed
+  if (config_.tags_modified_utc > 0 && config_.tags_modified_utc <= tags_synced_utc) {
+    VXCORE_LOG_DEBUG("Tags already synced: config=%lld, db=%lld", config_.tags_modified_utc,
+                     tags_synced_utc);
+    return VXCORE_OK;  // No sync needed
+  }
+
+  VXCORE_LOG_INFO("Syncing tags to MetadataStore: config=%lld, db=%lld", config_.tags_modified_utc,
+                  tags_synced_utc);
+
+  // 3. Begin transaction
+  if (!metadata_store_->BeginTransaction()) {
+    VXCORE_LOG_ERROR("Failed to begin transaction for tag sync");
+    return VXCORE_ERR_UNKNOWN;
+  }
+
+  bool success = true;
+
+  // 4. Sort tags by depth (root tags first, then children)
+  // Build a map of tag name -> depth
+  std::unordered_map<std::string, int> tag_depth;
+  for (const auto &tag : config_.tags) {
+    if (tag.parent.empty()) {
+      tag_depth[tag.name] = 0;
+    }
+  }
+
+  // Iteratively compute depths for tags with parents
+  bool changed = true;
+  while (changed) {
+    changed = false;
+    for (const auto &tag : config_.tags) {
+      if (tag_depth.find(tag.name) != tag_depth.end()) {
+        continue;
+      }
+      if (!tag.parent.empty() && tag_depth.find(tag.parent) != tag_depth.end()) {
+        tag_depth[tag.name] = tag_depth[tag.parent] + 1;
+        changed = true;
+      }
+    }
+  }
+
+  // Sort tags by depth
+  std::vector<const TagNode *> sorted_tags;
+  sorted_tags.reserve(config_.tags.size());
+  for (const auto &tag : config_.tags) {
+    sorted_tags.push_back(&tag);
+  }
+  std::sort(sorted_tags.begin(), sorted_tags.end(),
+            [&tag_depth](const TagNode *a, const TagNode *b) {
+              int da = tag_depth.count(a->name) ? tag_depth[a->name] : 999;
+              int db = tag_depth.count(b->name) ? tag_depth[b->name] : 999;
+              return da < db;
+            });
+
+  // 5. Create/update tags in depth order
+  for (const TagNode *tag : sorted_tags) {
+    StoreTagRecord store_tag;
+    store_tag.name = tag->name;
+    store_tag.parent_name = tag->parent;
+    store_tag.metadata = tag->metadata.dump();
+
+    if (!metadata_store_->CreateOrUpdateTag(store_tag)) {
+      VXCORE_LOG_ERROR("Failed to sync tag: %s", tag->name.c_str());
+      success = false;
+      break;
+    }
+  }
+
+  // 6. Delete orphan tags (tags in DB but not in config)
+  if (success) {
+    auto db_tags = metadata_store_->ListTags();
+    for (const auto &db_tag : db_tags) {
+      if (tag_depth.find(db_tag.name) == tag_depth.end()) {
+        VXCORE_LOG_INFO("Deleting orphan tag: %s", db_tag.name.c_str());
+        if (!metadata_store_->DeleteTag(db_tag.name)) {
+          VXCORE_LOG_WARN("Failed to delete orphan tag: %s", db_tag.name.c_str());
+          // Continue anyway - orphan cleanup is best-effort
+        }
+      }
+    }
+  }
+
+  // 7. Commit or rollback
+  if (success) {
+    if (!metadata_store_->CommitTransaction()) {
+      VXCORE_LOG_ERROR("Failed to commit tag sync transaction");
+      return VXCORE_ERR_UNKNOWN;
+    }
+  } else {
+    metadata_store_->RollbackTransaction();
+    return VXCORE_ERR_UNKNOWN;
+  }
+
+  // 8. Update tags_synced_utc in DB
+  int64_t sync_time =
+      config_.tags_modified_utc > 0 ? config_.tags_modified_utc : GetCurrentTimestampMillis();
+  metadata_store_->SetNotebookMetadata("tags_synced_utc", std::to_string(sync_time));
+
+  // 9. If config had tags_modified_utc=0, set it to current time and save
+  if (config_.tags_modified_utc == 0 && !config_.tags.empty()) {
+    config_.tags_modified_utc = sync_time;
+    // Note: UpdateConfig is virtual, will save to appropriate location
+    auto err = UpdateConfig(config_);
+    if (err != VXCORE_OK) {
+      VXCORE_LOG_WARN("Failed to update config after tag sync: error=%d", err);
+      // Don't fail - sync itself succeeded
+    }
+  }
+
+  VXCORE_LOG_INFO("Tag sync completed successfully");
+  return VXCORE_OK;
+}
+
 void Notebook::Close() {
   VXCORE_LOG_INFO("Closing notebook: id=%s", config_.id.c_str());
 
@@ -191,6 +327,7 @@ VxCoreError Notebook::CreateTag(const std::string &tag_name, const std::string &
   }
 
   config_.tags.emplace_back(tag_name, parent_tag);
+  config_.tags_modified_utc = GetCurrentTimestampMillis();
 
   auto err = UpdateConfig(config_);
   if (err != VXCORE_OK) {
@@ -323,6 +460,7 @@ VxCoreError Notebook::DeleteTag(const std::string &tag_name) {
     }
   }
 
+  config_.tags_modified_utc = GetCurrentTimestampMillis();
   auto err = UpdateConfig(config_);
   if (err != VXCORE_OK) {
     VXCORE_LOG_ERROR(
@@ -367,6 +505,7 @@ VxCoreError Notebook::MoveTag(const std::string &tag_name, const std::string &pa
 
   tag->parent = parent_tag;
 
+  config_.tags_modified_utc = GetCurrentTimestampMillis();
   auto err = UpdateConfig(config_);
   if (err != VXCORE_OK) {
     VXCORE_LOG_ERROR(

src/core/notebook.h

@@ -35,6 +35,7 @@ struct NotebookConfig {
   std::string attachments_folder;
   nlohmann::json metadata;
   std::vector<TagNode> tags;
+  int64_t tags_modified_utc;
 
   NotebookConfig();
 
@@ -101,6 +102,10 @@ class Notebook {
   // Returns VXCORE_OK on success, or error code on failure
   VxCoreError InitMetadataStore();
 
+  // Syncs tags from NotebookConfig to MetadataStore if config is newer
+  // Returns VXCORE_OK on success or if no sync needed
+  VxCoreError SyncTagsToMetadataStore();
+
   std::string GetDbPath() const;
   virtual std::string GetConfigPath() const = 0;
 

src/core/raw_notebook.cpp

@@ -80,6 +80,13 @@ VxCoreError RawNotebook::InitOnCreation() {
     return err;
   }
 
+  // Sync tags from NotebookConfig to MetadataStore
+  err = SyncTagsToMetadataStore();
+  if (err != VXCORE_OK) {
+    VXCORE_LOG_WARN("Tag sync failed on creation: root=%s, error=%d", root_folder_.c_str(), err);
+    // Continue anyway - tags will be synced on next open
+  }
+
   return VXCORE_OK;
 }
 
@@ -102,6 +109,14 @@ VxCoreError RawNotebook::Open(const std::string &local_data_folder, const std::s
     return err;
   }
 
+  // Sync tags from NotebookConfig to MetadataStore if needed
+  err = notebook->SyncTagsToMetadataStore();
+  if (err != VXCORE_OK) {
+    VXCORE_LOG_WARN("Tag sync failed on open: root=%s, id=%s, error=%d", root_folder.c_str(),
+                    id.c_str(), err);
+    // Continue anyway - tags will be synced on next open or RebuildCache
+  }
+
   out_notebook = std::move(notebook);
   return VXCORE_OK;
 }

src/db/db_manager.cpp

@@ -2,6 +2,8 @@
 
 #include <sqlite3.h>
 
+#include <optional>
+
 #include "db_schema.h"
 #include "utils/logger.h"
 

src/db/db_schema.h

@@ -10,7 +10,7 @@ namespace db {
 namespace schema {
 
 // Schema version for migration tracking
-constexpr int kCurrentSchemaVersion = 2;
+constexpr int kCurrentSchemaVersion = 3;
 
 // Folders table: stores folder hierarchy
 // parent_id references folders(id) - NULL for root folders
@@ -82,6 +82,14 @@ CREATE TABLE IF NOT EXISTS file_tags (
 CREATE INDEX IF NOT EXISTS idx_file_tags_tag ON file_tags(tag_id);
 )";
 
+// Notebook metadata: key-value store for notebook-level metadata
+inline constexpr const char* kCreateNotebookMetadataTable = R"(
+CREATE TABLE IF NOT EXISTS notebook_metadata (
+  key TEXT PRIMARY KEY,
+  value TEXT NOT NULL
+);
+)";
+
 // Schema version table for migrations
 inline constexpr const char* kCreateSchemaVersionTable = R"(
 CREATE TABLE IF NOT EXISTS schema_version (
@@ -92,18 +100,19 @@ CREATE TABLE IF NOT EXISTS schema_version (
 // Table names in reverse dependency order (safe for dropping)
 // When adding a new table, add it to this array in the appropriate position
 inline constexpr const char* kTableNames[] = {
-    "file_tags",       // Many-to-many relationship (depends on files, tags)
-    "files",           // Depends on folders
-    "tags",            // Independent
-    "folders",         // Independent (now includes sync state)
-    "schema_version",  // Independent
+    "file_tags",          // Many-to-many relationship (depends on files, tags)
+    "files",              // Depends on folders
+    "tags",               // Independent
+    "folders",            // Independent (now includes sync state)
+    "notebook_metadata",  // Independent (key-value store)
+    "schema_version",     // Independent
 };
 
 // Combined initialization script
 inline const std::string GetInitializationScript() {
   return std::string(kCreateFoldersTable) + "\n" + std::string(kCreateFilesTable) + "\n" +
          std::string(kCreateTagsTable) + "\n" + std::string(kCreateFileTagsTable) + "\n" +
-         std::string(kCreateSchemaVersionTable);
+         std::string(kCreateNotebookMetadataTable) + "\n" + std::string(kCreateSchemaVersionTable);
 }
 
 // Generate DROP TABLE statements for all tables