From 2d5eef74fd72d4e7a9c78fe568a400be007377ce Mon Sep 17 00:00:00 2001 From: Kaan Karaca Date: Sat, 25 Apr 2026 02:56:47 +0300 Subject: [PATCH 01/25] m2(deps): add db foundation dependencies --- apps/desktop-tauri/src-tauri/Cargo.toml | 6 +++++- 1 file changed, 5 insertions(+), 1 deletion(-) diff --git a/apps/desktop-tauri/src-tauri/Cargo.toml b/apps/desktop-tauri/src-tauri/Cargo.toml index 70335dac2..6311c5dad 100644 --- a/apps/desktop-tauri/src-tauri/Cargo.toml +++ b/apps/desktop-tauri/src-tauri/Cargo.toml @@ -19,7 +19,7 @@ tauri = { version = "2.10", features = [] } tauri-plugin-shell = "2" # Declared for later milestones — unused at M1 but compile-verified -rusqlite = { version = "0.32", features = ["bundled", "load_extension"], default-features = false } +rusqlite = { version = "0.32", features = ["bundled", "load_extension", "chrono", "serde_json", "hooks"] } yrs = "0.21" dryoc = "0.7" tokio = { version = "1.41", features = ["full"] } @@ -29,12 +29,16 @@ tracing-appender = "0.2" serde = { version = "1.0", features = ["derive"] } serde_json = "1.0" thiserror = "2.0" +directories = "5" specta = { version = "2.0.0-rc.20", features = ["derive"] } tauri-specta = { version = "2.0.0-rc.21", features = ["typescript"] } [features] custom-protocol = ["tauri/custom-protocol"] +[dev-dependencies] +tempfile = "3" + [[bin]] name = "generate_bindings" path = "src/bin/generate_bindings.rs" From 2e580af30f3bfd96589d2a3b2a7b2fefef17a06c Mon Sep 17 00:00:00 2001 From: Kaan Karaca Date: Sat, 25 Apr 2026 02:59:06 +0300 Subject: [PATCH 02/25] m2(db): add AppState Db and AppError --- apps/desktop-tauri/src-tauri/Cargo.toml | 1 + apps/desktop-tauri/src-tauri/src/app_state.rs | 13 ++++ apps/desktop-tauri/src-tauri/src/db/mod.rs | 63 +++++++++++++++++++ apps/desktop-tauri/src-tauri/src/error.rs | 50 +++++++++++++++ apps/desktop-tauri/src-tauri/src/lib.rs | 28 +++++++++ 5 files changed, 155 insertions(+) create mode 100644 apps/desktop-tauri/src-tauri/src/app_state.rs create mode 100644 apps/desktop-tauri/src-tauri/src/db/mod.rs create mode 100644 apps/desktop-tauri/src-tauri/src/error.rs diff --git a/apps/desktop-tauri/src-tauri/Cargo.toml b/apps/desktop-tauri/src-tauri/Cargo.toml index 6311c5dad..41c07bc28 100644 --- a/apps/desktop-tauri/src-tauri/Cargo.toml +++ b/apps/desktop-tauri/src-tauri/Cargo.toml @@ -35,6 +35,7 @@ tauri-specta = { version = "2.0.0-rc.21", features = ["typescript"] } [features] custom-protocol = ["tauri/custom-protocol"] +test-helpers = [] [dev-dependencies] tempfile = "3" diff --git a/apps/desktop-tauri/src-tauri/src/app_state.rs b/apps/desktop-tauri/src-tauri/src/app_state.rs new file mode 100644 index 000000000..f4b96213c --- /dev/null +++ b/apps/desktop-tauri/src-tauri/src/app_state.rs @@ -0,0 +1,13 @@ +//! Global runtime state shared across commands. + +use crate::db::Db; + +pub struct AppState { + pub db: Db, +} + +impl AppState { + pub fn new(db: Db) -> Self { + Self { db } + } +} diff --git a/apps/desktop-tauri/src-tauri/src/db/mod.rs b/apps/desktop-tauri/src-tauri/src/db/mod.rs new file mode 100644 index 000000000..009a6f568 --- /dev/null +++ b/apps/desktop-tauri/src-tauri/src/db/mod.rs @@ -0,0 +1,63 @@ +//! SQLite DB layer. Owns the single process-wide data DB connection. + +use crate::error::{AppError, AppResult}; +use rusqlite::Connection; +use std::{ + path::Path, + sync::{Arc, Mutex, MutexGuard}, +}; + +pub type DbGuard<'a> = MutexGuard<'a, Connection>; + +#[derive(Clone)] +pub struct Db { + conn: Arc>, +} + +impl Db { + pub fn open(path: impl AsRef) -> AppResult { + let path = path.as_ref(); + + if let Some(parent) = path.parent() { + std::fs::create_dir_all(parent)?; + } + + Self::with_init(Connection::open(path)?, |conn| { + conn.execute_batch( + "PRAGMA journal_mode = WAL; + PRAGMA synchronous = NORMAL; + PRAGMA foreign_keys = ON; + PRAGMA busy_timeout = 5000;", + ) + }) + } + + #[cfg(any(test, feature = "test-helpers"))] + pub fn open_memory() -> AppResult { + Self::with_init(Connection::open_in_memory()?, |conn| { + conn.execute_batch( + "PRAGMA journal_mode = MEMORY; + PRAGMA foreign_keys = ON;", + ) + }) + } + + pub fn with_conn(&self, f: impl FnOnce(&mut Connection) -> AppResult) -> AppResult { + let mut conn = self.conn()?; + f(&mut conn) + } + + pub fn conn(&self) -> AppResult> { + self.conn.lock().map_err(AppError::from) + } + + fn with_init( + conn: Connection, + init: impl FnOnce(&Connection) -> rusqlite::Result<()>, + ) -> AppResult { + init(&conn)?; + Ok(Self { + conn: Arc::new(Mutex::new(conn)), + }) + } +} diff --git a/apps/desktop-tauri/src-tauri/src/error.rs b/apps/desktop-tauri/src-tauri/src/error.rs new file mode 100644 index 000000000..7125940e5 --- /dev/null +++ b/apps/desktop-tauri/src-tauri/src/error.rs @@ -0,0 +1,50 @@ +use serde::Serialize; + +#[derive(Debug, thiserror::Error, Serialize, specta::Type)] +#[serde(tag = "kind", content = "message")] +pub enum AppError { + #[error("database error: {0}")] + Database(String), + #[error("crypto error: {0}")] + Crypto(String), + #[error("vault locked")] + VaultLocked, + #[error("invalid password")] + InvalidPassword, + #[error("not found: {0}")] + NotFound(String), + #[error("network error: {0}")] + Network(String), + #[error("conflict: {0}")] + Conflict(String), + #[error("validation error: {0}")] + Validation(String), + #[error("internal error: {0}")] + Internal(String), +} + +impl From for AppError { + fn from(err: rusqlite::Error) -> Self { + AppError::Database(err.to_string()) + } +} + +impl From for AppError { + fn from(err: std::io::Error) -> Self { + AppError::Internal(err.to_string()) + } +} + +impl From for AppError { + fn from(err: serde_json::Error) -> Self { + AppError::Validation(err.to_string()) + } +} + +impl From> for AppError { + fn from(err: std::sync::PoisonError) -> Self { + AppError::Internal(err.to_string()) + } +} + +pub type AppResult = Result; diff --git a/apps/desktop-tauri/src-tauri/src/lib.rs b/apps/desktop-tauri/src-tauri/src/lib.rs index 3bd384d2e..2b6985e36 100644 --- a/apps/desktop-tauri/src-tauri/src/lib.rs +++ b/apps/desktop-tauri/src-tauri/src/lib.rs @@ -1,9 +1,37 @@ +pub mod app_state; pub mod commands; +pub mod db; +pub mod error; + +use app_state::AppState; +use db::Db; +use directories::ProjectDirs; +use error::{AppError, AppResult}; +use std::path::PathBuf; + +fn resolve_db_path() -> AppResult { + let device = std::env::var("MEMRY_DEVICE").unwrap_or_else(|_| "default".to_string()); + let project_dirs = ProjectDirs::from("com", "memry", "memry") + .ok_or_else(|| AppError::Internal("could not determine OS project dirs".to_string()))?; + + Ok(project_dirs + .data_dir() + .join(format!("memry-{device}")) + .join("data.db")) +} + +fn init_app_state() -> AppResult { + let db_path = resolve_db_path()?; + let db = Db::open(db_path)?; + Ok(AppState::new(db)) +} #[cfg_attr(mobile, tauri::mobile_entry_point)] pub fn run() { + let app_state = init_app_state().expect("failed to initialize app state"); let builder = tauri::Builder::default() .plugin(tauri_plugin_shell::init()) + .manage(app_state) .setup(|_app| { tracing_subscriber::fmt() .with_env_filter( From d5e8a4dca399f79fe588dcc9ad90f4d1b0657313 Mon Sep 17 00:00:00 2001 From: Kaan Karaca Date: Sat, 25 Apr 2026 03:02:12 +0300 Subject: [PATCH 03/25] m2(migrations): add runner and placeholders --- apps/desktop-tauri/src-tauri/Cargo.toml | 4 + .../migrations/0000_thankful_luke_cage.sql | 1 + .../migrations/0001_married_shadow_king.sql | 1 + .../migrations/0002_broken_sleeper.sql | 1 + .../migrations/0003_shallow_gladiator.sql | 1 + .../migrations/0004_odd_silver_sable.sql | 1 + .../migrations/0005_old_mac_gargan.sql | 1 + .../migrations/0006_late_infant_terrible.sql | 1 + .../migrations/0007_safe_sunspot.sql | 1 + .../migrations/0008_blushing_magma.sql | 1 + .../migrations/0009_lumpy_gladiator.sql | 1 + .../0010_dizzy_natasha_romanoff.sql | 1 + .../migrations/0011_silent_shooting_star.sql | 1 + .../src-tauri/migrations/0012_lush_veda.sql | 1 + .../migrations/0013_last_guardian.sql | 1 + .../migrations/0014_dazzling_leopardon.sql | 1 + .../src-tauri/migrations/0015_brief_hex.sql | 1 + .../migrations/0016_lovely_mastermind.sql | 1 + .../migrations/0017_spotty_mongu.sql | 1 + .../0018_greedy_stepford_cuckoos.sql | 1 + .../0019_material_lethal_legion.sql | 1 + .../migrations/0020_search_reasons.sql | 1 + .../src-tauri/migrations/0021_inbox_jobs.sql | 1 + .../migrations/0022_notes_journal_vault.sql | 1 + .../migrations/0023_folder_configs.sql | 1 + .../0024_google_calendar_foundation.sql | 1 + .../migrations/0025_event_target_calendar.sql | 1 + .../migrations/0026_calendar_field_clocks.sql | 1 + .../migrations/0027_calendar_rich_fields.sql | 1 + .../0028_calendar_source_last_error.sql | 1 + .../src-tauri/src/db/migrations.rs | 166 ++++++++++++++++++ apps/desktop-tauri/src-tauri/src/db/mod.rs | 14 +- .../src-tauri/tests/migrations_test.rs | 59 +++++++ 33 files changed, 268 insertions(+), 4 deletions(-) create mode 100644 apps/desktop-tauri/src-tauri/migrations/0000_thankful_luke_cage.sql create mode 100644 apps/desktop-tauri/src-tauri/migrations/0001_married_shadow_king.sql create mode 100644 apps/desktop-tauri/src-tauri/migrations/0002_broken_sleeper.sql create mode 100644 apps/desktop-tauri/src-tauri/migrations/0003_shallow_gladiator.sql create mode 100644 apps/desktop-tauri/src-tauri/migrations/0004_odd_silver_sable.sql create mode 100644 apps/desktop-tauri/src-tauri/migrations/0005_old_mac_gargan.sql create mode 100644 apps/desktop-tauri/src-tauri/migrations/0006_late_infant_terrible.sql create mode 100644 apps/desktop-tauri/src-tauri/migrations/0007_safe_sunspot.sql create mode 100644 apps/desktop-tauri/src-tauri/migrations/0008_blushing_magma.sql create mode 100644 apps/desktop-tauri/src-tauri/migrations/0009_lumpy_gladiator.sql create mode 100644 apps/desktop-tauri/src-tauri/migrations/0010_dizzy_natasha_romanoff.sql create mode 100644 apps/desktop-tauri/src-tauri/migrations/0011_silent_shooting_star.sql create mode 100644 apps/desktop-tauri/src-tauri/migrations/0012_lush_veda.sql create mode 100644 apps/desktop-tauri/src-tauri/migrations/0013_last_guardian.sql create mode 100644 apps/desktop-tauri/src-tauri/migrations/0014_dazzling_leopardon.sql create mode 100644 apps/desktop-tauri/src-tauri/migrations/0015_brief_hex.sql create mode 100644 apps/desktop-tauri/src-tauri/migrations/0016_lovely_mastermind.sql create mode 100644 apps/desktop-tauri/src-tauri/migrations/0017_spotty_mongu.sql create mode 100644 apps/desktop-tauri/src-tauri/migrations/0018_greedy_stepford_cuckoos.sql create mode 100644 apps/desktop-tauri/src-tauri/migrations/0019_material_lethal_legion.sql create mode 100644 apps/desktop-tauri/src-tauri/migrations/0020_search_reasons.sql create mode 100644 apps/desktop-tauri/src-tauri/migrations/0021_inbox_jobs.sql create mode 100644 apps/desktop-tauri/src-tauri/migrations/0022_notes_journal_vault.sql create mode 100644 apps/desktop-tauri/src-tauri/migrations/0023_folder_configs.sql create mode 100644 apps/desktop-tauri/src-tauri/migrations/0024_google_calendar_foundation.sql create mode 100644 apps/desktop-tauri/src-tauri/migrations/0025_event_target_calendar.sql create mode 100644 apps/desktop-tauri/src-tauri/migrations/0026_calendar_field_clocks.sql create mode 100644 apps/desktop-tauri/src-tauri/migrations/0027_calendar_rich_fields.sql create mode 100644 apps/desktop-tauri/src-tauri/migrations/0028_calendar_source_last_error.sql create mode 100644 apps/desktop-tauri/src-tauri/src/db/migrations.rs create mode 100644 apps/desktop-tauri/src-tauri/tests/migrations_test.rs diff --git a/apps/desktop-tauri/src-tauri/Cargo.toml b/apps/desktop-tauri/src-tauri/Cargo.toml index 41c07bc28..c2a8c69ee 100644 --- a/apps/desktop-tauri/src-tauri/Cargo.toml +++ b/apps/desktop-tauri/src-tauri/Cargo.toml @@ -43,3 +43,7 @@ tempfile = "3" [[bin]] name = "generate_bindings" path = "src/bin/generate_bindings.rs" + +[[test]] +name = "migrations_test" +required-features = ["test-helpers"] diff --git a/apps/desktop-tauri/src-tauri/migrations/0000_thankful_luke_cage.sql b/apps/desktop-tauri/src-tauri/migrations/0000_thankful_luke_cage.sql new file mode 100644 index 000000000..463109021 --- /dev/null +++ b/apps/desktop-tauri/src-tauri/migrations/0000_thankful_luke_cage.sql @@ -0,0 +1 @@ +-- placeholder; real content lands in Phase B diff --git a/apps/desktop-tauri/src-tauri/migrations/0001_married_shadow_king.sql b/apps/desktop-tauri/src-tauri/migrations/0001_married_shadow_king.sql new file mode 100644 index 000000000..463109021 --- /dev/null +++ b/apps/desktop-tauri/src-tauri/migrations/0001_married_shadow_king.sql @@ -0,0 +1 @@ +-- placeholder; real content lands in Phase B diff --git a/apps/desktop-tauri/src-tauri/migrations/0002_broken_sleeper.sql b/apps/desktop-tauri/src-tauri/migrations/0002_broken_sleeper.sql new file mode 100644 index 000000000..463109021 --- /dev/null +++ b/apps/desktop-tauri/src-tauri/migrations/0002_broken_sleeper.sql @@ -0,0 +1 @@ +-- placeholder; real content lands in Phase B diff --git a/apps/desktop-tauri/src-tauri/migrations/0003_shallow_gladiator.sql b/apps/desktop-tauri/src-tauri/migrations/0003_shallow_gladiator.sql new file mode 100644 index 000000000..463109021 --- /dev/null +++ b/apps/desktop-tauri/src-tauri/migrations/0003_shallow_gladiator.sql @@ -0,0 +1 @@ +-- placeholder; real content lands in Phase B diff --git a/apps/desktop-tauri/src-tauri/migrations/0004_odd_silver_sable.sql b/apps/desktop-tauri/src-tauri/migrations/0004_odd_silver_sable.sql new file mode 100644 index 000000000..463109021 --- /dev/null +++ b/apps/desktop-tauri/src-tauri/migrations/0004_odd_silver_sable.sql @@ -0,0 +1 @@ +-- placeholder; real content lands in Phase B diff --git a/apps/desktop-tauri/src-tauri/migrations/0005_old_mac_gargan.sql b/apps/desktop-tauri/src-tauri/migrations/0005_old_mac_gargan.sql new file mode 100644 index 000000000..463109021 --- /dev/null +++ b/apps/desktop-tauri/src-tauri/migrations/0005_old_mac_gargan.sql @@ -0,0 +1 @@ +-- placeholder; real content lands in Phase B diff --git a/apps/desktop-tauri/src-tauri/migrations/0006_late_infant_terrible.sql b/apps/desktop-tauri/src-tauri/migrations/0006_late_infant_terrible.sql new file mode 100644 index 000000000..463109021 --- /dev/null +++ b/apps/desktop-tauri/src-tauri/migrations/0006_late_infant_terrible.sql @@ -0,0 +1 @@ +-- placeholder; real content lands in Phase B diff --git a/apps/desktop-tauri/src-tauri/migrations/0007_safe_sunspot.sql b/apps/desktop-tauri/src-tauri/migrations/0007_safe_sunspot.sql new file mode 100644 index 000000000..463109021 --- /dev/null +++ b/apps/desktop-tauri/src-tauri/migrations/0007_safe_sunspot.sql @@ -0,0 +1 @@ +-- placeholder; real content lands in Phase B diff --git a/apps/desktop-tauri/src-tauri/migrations/0008_blushing_magma.sql b/apps/desktop-tauri/src-tauri/migrations/0008_blushing_magma.sql new file mode 100644 index 000000000..463109021 --- /dev/null +++ b/apps/desktop-tauri/src-tauri/migrations/0008_blushing_magma.sql @@ -0,0 +1 @@ +-- placeholder; real content lands in Phase B diff --git a/apps/desktop-tauri/src-tauri/migrations/0009_lumpy_gladiator.sql b/apps/desktop-tauri/src-tauri/migrations/0009_lumpy_gladiator.sql new file mode 100644 index 000000000..463109021 --- /dev/null +++ b/apps/desktop-tauri/src-tauri/migrations/0009_lumpy_gladiator.sql @@ -0,0 +1 @@ +-- placeholder; real content lands in Phase B diff --git a/apps/desktop-tauri/src-tauri/migrations/0010_dizzy_natasha_romanoff.sql b/apps/desktop-tauri/src-tauri/migrations/0010_dizzy_natasha_romanoff.sql new file mode 100644 index 000000000..463109021 --- /dev/null +++ b/apps/desktop-tauri/src-tauri/migrations/0010_dizzy_natasha_romanoff.sql @@ -0,0 +1 @@ +-- placeholder; real content lands in Phase B diff --git a/apps/desktop-tauri/src-tauri/migrations/0011_silent_shooting_star.sql b/apps/desktop-tauri/src-tauri/migrations/0011_silent_shooting_star.sql new file mode 100644 index 000000000..463109021 --- /dev/null +++ b/apps/desktop-tauri/src-tauri/migrations/0011_silent_shooting_star.sql @@ -0,0 +1 @@ +-- placeholder; real content lands in Phase B diff --git a/apps/desktop-tauri/src-tauri/migrations/0012_lush_veda.sql b/apps/desktop-tauri/src-tauri/migrations/0012_lush_veda.sql new file mode 100644 index 000000000..463109021 --- /dev/null +++ b/apps/desktop-tauri/src-tauri/migrations/0012_lush_veda.sql @@ -0,0 +1 @@ +-- placeholder; real content lands in Phase B diff --git a/apps/desktop-tauri/src-tauri/migrations/0013_last_guardian.sql b/apps/desktop-tauri/src-tauri/migrations/0013_last_guardian.sql new file mode 100644 index 000000000..463109021 --- /dev/null +++ b/apps/desktop-tauri/src-tauri/migrations/0013_last_guardian.sql @@ -0,0 +1 @@ +-- placeholder; real content lands in Phase B diff --git a/apps/desktop-tauri/src-tauri/migrations/0014_dazzling_leopardon.sql b/apps/desktop-tauri/src-tauri/migrations/0014_dazzling_leopardon.sql new file mode 100644 index 000000000..463109021 --- /dev/null +++ b/apps/desktop-tauri/src-tauri/migrations/0014_dazzling_leopardon.sql @@ -0,0 +1 @@ +-- placeholder; real content lands in Phase B diff --git a/apps/desktop-tauri/src-tauri/migrations/0015_brief_hex.sql b/apps/desktop-tauri/src-tauri/migrations/0015_brief_hex.sql new file mode 100644 index 000000000..463109021 --- /dev/null +++ b/apps/desktop-tauri/src-tauri/migrations/0015_brief_hex.sql @@ -0,0 +1 @@ +-- placeholder; real content lands in Phase B diff --git a/apps/desktop-tauri/src-tauri/migrations/0016_lovely_mastermind.sql b/apps/desktop-tauri/src-tauri/migrations/0016_lovely_mastermind.sql new file mode 100644 index 000000000..463109021 --- /dev/null +++ b/apps/desktop-tauri/src-tauri/migrations/0016_lovely_mastermind.sql @@ -0,0 +1 @@ +-- placeholder; real content lands in Phase B diff --git a/apps/desktop-tauri/src-tauri/migrations/0017_spotty_mongu.sql b/apps/desktop-tauri/src-tauri/migrations/0017_spotty_mongu.sql new file mode 100644 index 000000000..463109021 --- /dev/null +++ b/apps/desktop-tauri/src-tauri/migrations/0017_spotty_mongu.sql @@ -0,0 +1 @@ +-- placeholder; real content lands in Phase B diff --git a/apps/desktop-tauri/src-tauri/migrations/0018_greedy_stepford_cuckoos.sql b/apps/desktop-tauri/src-tauri/migrations/0018_greedy_stepford_cuckoos.sql new file mode 100644 index 000000000..463109021 --- /dev/null +++ b/apps/desktop-tauri/src-tauri/migrations/0018_greedy_stepford_cuckoos.sql @@ -0,0 +1 @@ +-- placeholder; real content lands in Phase B diff --git a/apps/desktop-tauri/src-tauri/migrations/0019_material_lethal_legion.sql b/apps/desktop-tauri/src-tauri/migrations/0019_material_lethal_legion.sql new file mode 100644 index 000000000..463109021 --- /dev/null +++ b/apps/desktop-tauri/src-tauri/migrations/0019_material_lethal_legion.sql @@ -0,0 +1 @@ +-- placeholder; real content lands in Phase B diff --git a/apps/desktop-tauri/src-tauri/migrations/0020_search_reasons.sql b/apps/desktop-tauri/src-tauri/migrations/0020_search_reasons.sql new file mode 100644 index 000000000..463109021 --- /dev/null +++ b/apps/desktop-tauri/src-tauri/migrations/0020_search_reasons.sql @@ -0,0 +1 @@ +-- placeholder; real content lands in Phase B diff --git a/apps/desktop-tauri/src-tauri/migrations/0021_inbox_jobs.sql b/apps/desktop-tauri/src-tauri/migrations/0021_inbox_jobs.sql new file mode 100644 index 000000000..463109021 --- /dev/null +++ b/apps/desktop-tauri/src-tauri/migrations/0021_inbox_jobs.sql @@ -0,0 +1 @@ +-- placeholder; real content lands in Phase B diff --git a/apps/desktop-tauri/src-tauri/migrations/0022_notes_journal_vault.sql b/apps/desktop-tauri/src-tauri/migrations/0022_notes_journal_vault.sql new file mode 100644 index 000000000..463109021 --- /dev/null +++ b/apps/desktop-tauri/src-tauri/migrations/0022_notes_journal_vault.sql @@ -0,0 +1 @@ +-- placeholder; real content lands in Phase B diff --git a/apps/desktop-tauri/src-tauri/migrations/0023_folder_configs.sql b/apps/desktop-tauri/src-tauri/migrations/0023_folder_configs.sql new file mode 100644 index 000000000..463109021 --- /dev/null +++ b/apps/desktop-tauri/src-tauri/migrations/0023_folder_configs.sql @@ -0,0 +1 @@ +-- placeholder; real content lands in Phase B diff --git a/apps/desktop-tauri/src-tauri/migrations/0024_google_calendar_foundation.sql b/apps/desktop-tauri/src-tauri/migrations/0024_google_calendar_foundation.sql new file mode 100644 index 000000000..463109021 --- /dev/null +++ b/apps/desktop-tauri/src-tauri/migrations/0024_google_calendar_foundation.sql @@ -0,0 +1 @@ +-- placeholder; real content lands in Phase B diff --git a/apps/desktop-tauri/src-tauri/migrations/0025_event_target_calendar.sql b/apps/desktop-tauri/src-tauri/migrations/0025_event_target_calendar.sql new file mode 100644 index 000000000..463109021 --- /dev/null +++ b/apps/desktop-tauri/src-tauri/migrations/0025_event_target_calendar.sql @@ -0,0 +1 @@ +-- placeholder; real content lands in Phase B diff --git a/apps/desktop-tauri/src-tauri/migrations/0026_calendar_field_clocks.sql b/apps/desktop-tauri/src-tauri/migrations/0026_calendar_field_clocks.sql new file mode 100644 index 000000000..463109021 --- /dev/null +++ b/apps/desktop-tauri/src-tauri/migrations/0026_calendar_field_clocks.sql @@ -0,0 +1 @@ +-- placeholder; real content lands in Phase B diff --git a/apps/desktop-tauri/src-tauri/migrations/0027_calendar_rich_fields.sql b/apps/desktop-tauri/src-tauri/migrations/0027_calendar_rich_fields.sql new file mode 100644 index 000000000..463109021 --- /dev/null +++ b/apps/desktop-tauri/src-tauri/migrations/0027_calendar_rich_fields.sql @@ -0,0 +1 @@ +-- placeholder; real content lands in Phase B diff --git a/apps/desktop-tauri/src-tauri/migrations/0028_calendar_source_last_error.sql b/apps/desktop-tauri/src-tauri/migrations/0028_calendar_source_last_error.sql new file mode 100644 index 000000000..463109021 --- /dev/null +++ b/apps/desktop-tauri/src-tauri/migrations/0028_calendar_source_last_error.sql @@ -0,0 +1 @@ +-- placeholder; real content lands in Phase B diff --git a/apps/desktop-tauri/src-tauri/src/db/migrations.rs b/apps/desktop-tauri/src-tauri/src/db/migrations.rs new file mode 100644 index 000000000..707825558 --- /dev/null +++ b/apps/desktop-tauri/src-tauri/src/db/migrations.rs @@ -0,0 +1,166 @@ +use crate::error::{AppError, AppResult}; +use rusqlite::{params, Connection}; +use std::collections::HashSet; + +pub static EMBEDDED: &[(&str, &str)] = &MIGRATIONS; + +static MIGRATIONS: [(&str, &str); 29] = [ + ( + "0000_thankful_luke_cage.sql", + include_str!("../../migrations/0000_thankful_luke_cage.sql"), + ), + ( + "0001_married_shadow_king.sql", + include_str!("../../migrations/0001_married_shadow_king.sql"), + ), + ( + "0002_broken_sleeper.sql", + include_str!("../../migrations/0002_broken_sleeper.sql"), + ), + ( + "0003_shallow_gladiator.sql", + include_str!("../../migrations/0003_shallow_gladiator.sql"), + ), + ( + "0004_odd_silver_sable.sql", + include_str!("../../migrations/0004_odd_silver_sable.sql"), + ), + ( + "0005_old_mac_gargan.sql", + include_str!("../../migrations/0005_old_mac_gargan.sql"), + ), + ( + "0006_late_infant_terrible.sql", + include_str!("../../migrations/0006_late_infant_terrible.sql"), + ), + ( + "0007_safe_sunspot.sql", + include_str!("../../migrations/0007_safe_sunspot.sql"), + ), + ( + "0008_blushing_magma.sql", + include_str!("../../migrations/0008_blushing_magma.sql"), + ), + ( + "0009_lumpy_gladiator.sql", + include_str!("../../migrations/0009_lumpy_gladiator.sql"), + ), + ( + "0010_dizzy_natasha_romanoff.sql", + include_str!("../../migrations/0010_dizzy_natasha_romanoff.sql"), + ), + ( + "0011_silent_shooting_star.sql", + include_str!("../../migrations/0011_silent_shooting_star.sql"), + ), + ( + "0012_lush_veda.sql", + include_str!("../../migrations/0012_lush_veda.sql"), + ), + ( + "0013_last_guardian.sql", + include_str!("../../migrations/0013_last_guardian.sql"), + ), + ( + "0014_dazzling_leopardon.sql", + include_str!("../../migrations/0014_dazzling_leopardon.sql"), + ), + ( + "0015_brief_hex.sql", + include_str!("../../migrations/0015_brief_hex.sql"), + ), + ( + "0016_lovely_mastermind.sql", + include_str!("../../migrations/0016_lovely_mastermind.sql"), + ), + ( + "0017_spotty_mongu.sql", + include_str!("../../migrations/0017_spotty_mongu.sql"), + ), + ( + "0018_greedy_stepford_cuckoos.sql", + include_str!("../../migrations/0018_greedy_stepford_cuckoos.sql"), + ), + ( + "0019_material_lethal_legion.sql", + include_str!("../../migrations/0019_material_lethal_legion.sql"), + ), + ( + "0020_search_reasons.sql", + include_str!("../../migrations/0020_search_reasons.sql"), + ), + ( + "0021_inbox_jobs.sql", + include_str!("../../migrations/0021_inbox_jobs.sql"), + ), + ( + "0022_notes_journal_vault.sql", + include_str!("../../migrations/0022_notes_journal_vault.sql"), + ), + ( + "0023_folder_configs.sql", + include_str!("../../migrations/0023_folder_configs.sql"), + ), + ( + "0024_google_calendar_foundation.sql", + include_str!("../../migrations/0024_google_calendar_foundation.sql"), + ), + ( + "0025_event_target_calendar.sql", + include_str!("../../migrations/0025_event_target_calendar.sql"), + ), + ( + "0026_calendar_field_clocks.sql", + include_str!("../../migrations/0026_calendar_field_clocks.sql"), + ), + ( + "0027_calendar_rich_fields.sql", + include_str!("../../migrations/0027_calendar_rich_fields.sql"), + ), + ( + "0028_calendar_source_last_error.sql", + include_str!("../../migrations/0028_calendar_source_last_error.sql"), + ), +]; + +pub fn bootstrap(conn: &mut Connection) -> AppResult<()> { + conn.execute_batch( + "CREATE TABLE IF NOT EXISTS schema_migrations ( + name TEXT PRIMARY KEY NOT NULL, + applied_at TEXT NOT NULL DEFAULT (strftime('%Y-%m-%dT%H:%M:%fZ', 'now')) + );", + )?; + + Ok(()) +} + +pub fn apply_pending(conn: &mut Connection) -> AppResult<()> { + bootstrap(conn)?; + + let applied = applied_migrations(conn)?; + + for (name, sql) in EMBEDDED { + if applied.contains(*name) { + continue; + } + + let tx = conn.transaction()?; + tx.execute_batch(sql) + .map_err(|err| AppError::Database(format!("migration {name} failed: {err}")))?; + tx.execute( + "INSERT INTO schema_migrations (name) VALUES (?1)", + params![name], + )?; + tx.commit()?; + } + + Ok(()) +} + +fn applied_migrations(conn: &Connection) -> AppResult> { + let mut stmt = conn.prepare("SELECT name FROM schema_migrations")?; + let rows = stmt.query_map([], |row| row.get::<_, String>(0))?; + let applied = rows.collect::, _>>()?; + + Ok(applied) +} diff --git a/apps/desktop-tauri/src-tauri/src/db/mod.rs b/apps/desktop-tauri/src-tauri/src/db/mod.rs index 009a6f568..5afebd427 100644 --- a/apps/desktop-tauri/src-tauri/src/db/mod.rs +++ b/apps/desktop-tauri/src-tauri/src/db/mod.rs @@ -7,6 +7,8 @@ use std::{ sync::{Arc, Mutex, MutexGuard}, }; +pub mod migrations; + pub type DbGuard<'a> = MutexGuard<'a, Connection>; #[derive(Clone)] @@ -22,24 +24,28 @@ impl Db { std::fs::create_dir_all(parent)?; } - Self::with_init(Connection::open(path)?, |conn| { + let db = Self::with_init(Connection::open(path)?, |conn| { conn.execute_batch( "PRAGMA journal_mode = WAL; PRAGMA synchronous = NORMAL; PRAGMA foreign_keys = ON; PRAGMA busy_timeout = 5000;", ) - }) + })?; + db.with_conn(migrations::apply_pending)?; + Ok(db) } #[cfg(any(test, feature = "test-helpers"))] pub fn open_memory() -> AppResult { - Self::with_init(Connection::open_in_memory()?, |conn| { + let db = Self::with_init(Connection::open_in_memory()?, |conn| { conn.execute_batch( "PRAGMA journal_mode = MEMORY; PRAGMA foreign_keys = ON;", ) - }) + })?; + db.with_conn(migrations::apply_pending)?; + Ok(db) } pub fn with_conn(&self, f: impl FnOnce(&mut Connection) -> AppResult) -> AppResult { diff --git a/apps/desktop-tauri/src-tauri/tests/migrations_test.rs b/apps/desktop-tauri/src-tauri/tests/migrations_test.rs new file mode 100644 index 000000000..d95750558 --- /dev/null +++ b/apps/desktop-tauri/src-tauri/tests/migrations_test.rs @@ -0,0 +1,59 @@ +use memry_desktop_tauri_lib::db::migrations; +use rusqlite::Connection; + +#[test] +fn bootstraps_schema_migrations_table() { + let mut conn = Connection::open_in_memory().unwrap(); + migrations::bootstrap(&mut conn).unwrap(); + + let exists: i64 = conn + .query_row( + "SELECT COUNT(*) FROM sqlite_master WHERE type='table' AND name='schema_migrations'", + [], + |row| row.get(0), + ) + .unwrap(); + + assert_eq!(exists, 1); +} + +#[test] +fn bootstrap_is_idempotent() { + let mut conn = Connection::open_in_memory().unwrap(); + + migrations::bootstrap(&mut conn).unwrap(); + migrations::bootstrap(&mut conn).unwrap(); +} + +#[test] +fn applies_embedded_migrations_in_order_and_records_them() { + let mut conn = Connection::open_in_memory().unwrap(); + + migrations::apply_pending(&mut conn).unwrap(); + + let applied: Vec = { + let mut stmt = conn + .prepare("SELECT name FROM schema_migrations ORDER BY applied_at, name") + .unwrap(); + stmt.query_map([], |row| row.get(0)) + .unwrap() + .collect::>() + .unwrap() + }; + let expected: Vec = migrations::EMBEDDED + .iter() + .map(|(name, _sql)| (*name).to_string()) + .collect(); + + assert_eq!(applied, expected); + + migrations::apply_pending(&mut conn).unwrap(); + + let still_applied: i64 = conn + .query_row("SELECT COUNT(*) FROM schema_migrations", [], |row| { + row.get(0) + }) + .unwrap(); + + assert_eq!(still_applied, expected.len() as i64); +} From 6bae9e1b97548836b1a8baa752f553379e6837a5 Mon Sep 17 00:00:00 2001 From: Kaan Karaca Date: Sat, 25 Apr 2026 03:12:20 +0300 Subject: [PATCH 04/25] m2(migrations): port 0000 core schema (projects/statuses/tasks/task_notes/task_tags/inbox_items/saved_filters/settings) --- .../migrations/0000_thankful_luke_cage.sql | 102 +++++++++++++++++- .../src-tauri/tests/migrations_test.rs | 26 +++++ 2 files changed, 127 insertions(+), 1 deletion(-) diff --git a/apps/desktop-tauri/src-tauri/migrations/0000_thankful_luke_cage.sql b/apps/desktop-tauri/src-tauri/migrations/0000_thankful_luke_cage.sql index 463109021..7117c8b0e 100644 --- a/apps/desktop-tauri/src-tauri/migrations/0000_thankful_luke_cage.sql +++ b/apps/desktop-tauri/src-tauri/migrations/0000_thankful_luke_cage.sql @@ -1 +1,101 @@ --- placeholder; real content lands in Phase B +-- Port of apps/desktop/src/main/database/drizzle-data/0000_thankful_luke_cage.sql +-- Drizzle `--> statement-breakpoint` markers stripped; identifiers unbacktick'd; +-- boolean DEFAULT literals normalized to integer 0/1 for rusqlite. + +CREATE TABLE IF NOT EXISTS projects ( + id text PRIMARY KEY NOT NULL, + name text NOT NULL, + description text, + color text DEFAULT '#6366f1' NOT NULL, + icon text, + position integer DEFAULT 0 NOT NULL, + is_inbox integer DEFAULT 0 NOT NULL, + created_at text DEFAULT (datetime('now')) NOT NULL, + modified_at text DEFAULT (datetime('now')) NOT NULL, + archived_at text +); + +CREATE TABLE IF NOT EXISTS statuses ( + id text PRIMARY KEY NOT NULL, + project_id text NOT NULL, + name text NOT NULL, + color text DEFAULT '#6b7280' NOT NULL, + position integer DEFAULT 0 NOT NULL, + is_default integer DEFAULT 0 NOT NULL, + is_done integer DEFAULT 0 NOT NULL, + created_at text DEFAULT (datetime('now')) NOT NULL, + FOREIGN KEY (project_id) REFERENCES projects(id) ON UPDATE no action ON DELETE cascade +); + +CREATE INDEX IF NOT EXISTS idx_statuses_project ON statuses (project_id); + +CREATE TABLE IF NOT EXISTS tasks ( + id text PRIMARY KEY NOT NULL, + project_id text NOT NULL, + status_id text, + parent_id text, + title text NOT NULL, + description text, + priority integer DEFAULT 0 NOT NULL, + position integer DEFAULT 0 NOT NULL, + due_date text, + due_time text, + start_date text, + repeat_config text, + repeat_from text, + source_note_id text, + completed_at text, + archived_at text, + created_at text DEFAULT (datetime('now')) NOT NULL, + modified_at text DEFAULT (datetime('now')) NOT NULL, + FOREIGN KEY (project_id) REFERENCES projects(id) ON UPDATE no action ON DELETE cascade, + FOREIGN KEY (status_id) REFERENCES statuses(id) ON UPDATE no action ON DELETE set null +); + +CREATE INDEX IF NOT EXISTS idx_tasks_project ON tasks (project_id); +CREATE INDEX IF NOT EXISTS idx_tasks_status ON tasks (status_id); +CREATE INDEX IF NOT EXISTS idx_tasks_parent ON tasks (parent_id); +CREATE INDEX IF NOT EXISTS idx_tasks_due_date ON tasks (due_date); +CREATE INDEX IF NOT EXISTS idx_tasks_completed ON tasks (completed_at); + +CREATE TABLE IF NOT EXISTS task_notes ( + task_id text NOT NULL, + note_id text NOT NULL, + created_at text DEFAULT (datetime('now')) NOT NULL, + PRIMARY KEY(task_id, note_id), + FOREIGN KEY (task_id) REFERENCES tasks(id) ON UPDATE no action ON DELETE cascade +); + +CREATE TABLE IF NOT EXISTS task_tags ( + task_id text NOT NULL, + tag text NOT NULL, + PRIMARY KEY(task_id, tag), + FOREIGN KEY (task_id) REFERENCES tasks(id) ON UPDATE no action ON DELETE cascade +); + +CREATE INDEX IF NOT EXISTS idx_task_tags_tag ON task_tags (tag); + +CREATE TABLE IF NOT EXISTS inbox_items ( + id text PRIMARY KEY NOT NULL, + type text NOT NULL, + content text NOT NULL, + metadata text, + created_at text DEFAULT (datetime('now')) NOT NULL, + filed_at text +); + +CREATE INDEX IF NOT EXISTS idx_inbox_type ON inbox_items (type); + +CREATE TABLE IF NOT EXISTS saved_filters ( + id text PRIMARY KEY NOT NULL, + name text NOT NULL, + config text NOT NULL, + position integer DEFAULT 0 NOT NULL, + created_at text DEFAULT (datetime('now')) NOT NULL +); + +CREATE TABLE IF NOT EXISTS settings ( + key text PRIMARY KEY NOT NULL, + value text NOT NULL, + modified_at text DEFAULT (datetime('now')) NOT NULL +); diff --git a/apps/desktop-tauri/src-tauri/tests/migrations_test.rs b/apps/desktop-tauri/src-tauri/tests/migrations_test.rs index d95750558..a688ad0dc 100644 --- a/apps/desktop-tauri/src-tauri/tests/migrations_test.rs +++ b/apps/desktop-tauri/src-tauri/tests/migrations_test.rs @@ -57,3 +57,29 @@ fn applies_embedded_migrations_in_order_and_records_them() { assert_eq!(still_applied, expected.len() as i64); } + +#[test] +fn migration_0000_creates_core_tables() { + let mut conn = Connection::open_in_memory().unwrap(); + migrations::apply_pending(&mut conn).unwrap(); + + for table in [ + "projects", + "statuses", + "tasks", + "task_notes", + "task_tags", + "inbox_items", + "saved_filters", + "settings", + ] { + let exists: i64 = conn + .query_row( + "SELECT COUNT(*) FROM sqlite_master WHERE type='table' AND name=?1", + [table], + |row| row.get(0), + ) + .unwrap(); + assert_eq!(exists, 1, "table {table} missing after migration 0000"); + } +} From a317b2b924e5f0d30baf2daeef3df4e1e140c9b2 Mon Sep 17 00:00:00 2001 From: Kaan Karaca Date: Sat, 25 Apr 2026 03:14:09 +0300 Subject: [PATCH 05/25] m2(migrations): port 0001-0004 (bookmarks, inbox extensions, suggestion_feedback, reminders) --- .../migrations/0001_married_shadow_king.sql | 16 +++- .../migrations/0002_broken_sleeper.sql | 87 ++++++++++++++++++- .../migrations/0003_shallow_gladiator.sql | 20 ++++- .../migrations/0004_odd_silver_sable.sql | 25 +++++- 4 files changed, 144 insertions(+), 4 deletions(-) diff --git a/apps/desktop-tauri/src-tauri/migrations/0001_married_shadow_king.sql b/apps/desktop-tauri/src-tauri/migrations/0001_married_shadow_king.sql index 463109021..76147138f 100644 --- a/apps/desktop-tauri/src-tauri/migrations/0001_married_shadow_king.sql +++ b/apps/desktop-tauri/src-tauri/migrations/0001_married_shadow_king.sql @@ -1 +1,15 @@ --- placeholder; real content lands in Phase B +-- Port of apps/desktop/src/main/database/drizzle-data/0001_married_shadow_king.sql +-- Drizzle `--> statement-breakpoint` markers stripped; identifiers unbacktick'd. + +CREATE TABLE bookmarks ( + id text PRIMARY KEY NOT NULL, + item_type text NOT NULL, + item_id text NOT NULL, + position integer DEFAULT 0 NOT NULL, + created_at text DEFAULT (datetime('now')) NOT NULL +); + +CREATE UNIQUE INDEX idx_bookmarks_unique_item ON bookmarks (item_type, item_id); +CREATE INDEX idx_bookmarks_item_type ON bookmarks (item_type); +CREATE INDEX idx_bookmarks_position ON bookmarks (position); +CREATE INDEX idx_bookmarks_created ON bookmarks (created_at); diff --git a/apps/desktop-tauri/src-tauri/migrations/0002_broken_sleeper.sql b/apps/desktop-tauri/src-tauri/migrations/0002_broken_sleeper.sql index 463109021..dc3dff8e8 100644 --- a/apps/desktop-tauri/src-tauri/migrations/0002_broken_sleeper.sql +++ b/apps/desktop-tauri/src-tauri/migrations/0002_broken_sleeper.sql @@ -1 +1,86 @@ --- placeholder; real content lands in Phase B +-- Port of apps/desktop/src/main/database/drizzle-data/0002_broken_sleeper.sql +-- Drizzle `--> statement-breakpoint` markers stripped; identifiers unbacktick'd. +-- Note: PRAGMA foreign_keys=OFF/ON inside a transaction is silently no-op'd +-- by SQLite, but kept verbatim because Drizzle production runs it that way. + +CREATE TABLE filing_history ( + id text PRIMARY KEY NOT NULL, + item_type text NOT NULL, + item_content text, + filed_to text NOT NULL, + filed_action text NOT NULL, + tags text, + filed_at text DEFAULT (datetime('now')) NOT NULL +); + +CREATE INDEX idx_filing_history_type ON filing_history (item_type); +CREATE INDEX idx_filing_history_filed_at ON filing_history (filed_at); + +CREATE TABLE inbox_item_tags ( + id text PRIMARY KEY NOT NULL, + item_id text NOT NULL, + tag text NOT NULL, + created_at text DEFAULT (datetime('now')) NOT NULL, + FOREIGN KEY (item_id) REFERENCES inbox_items(id) ON UPDATE no action ON DELETE cascade +); + +CREATE INDEX idx_inbox_tags_item ON inbox_item_tags (item_id); +CREATE INDEX idx_inbox_tags_tag ON inbox_item_tags (tag); + +CREATE TABLE inbox_stats ( + id text PRIMARY KEY NOT NULL, + date text NOT NULL, + capture_count_link integer DEFAULT 0, + capture_count_note integer DEFAULT 0, + capture_count_image integer DEFAULT 0, + capture_count_voice integer DEFAULT 0, + capture_count_clip integer DEFAULT 0, + capture_count_pdf integer DEFAULT 0, + capture_count_social integer DEFAULT 0, + processed_count integer DEFAULT 0, + archived_count integer DEFAULT 0 +); + +CREATE UNIQUE INDEX inbox_stats_date_unique ON inbox_stats (date); +CREATE INDEX idx_inbox_stats_date ON inbox_stats (date); + +PRAGMA foreign_keys=OFF; + +CREATE TABLE __new_inbox_items ( + id text PRIMARY KEY NOT NULL, + type text NOT NULL, + title text NOT NULL, + content text, + created_at text DEFAULT (datetime('now')) NOT NULL, + modified_at text DEFAULT (datetime('now')) NOT NULL, + filed_at text, + filed_to text, + filed_action text, + snoozed_until text, + snooze_reason text, + processing_status text DEFAULT 'complete', + processing_error text, + metadata text, + attachment_path text, + thumbnail_path text, + transcription text, + transcription_status text, + source_url text, + source_title text, + archived_at text +); + +INSERT INTO __new_inbox_items("id", "type", "title", "content", "created_at", "modified_at", "filed_at", "metadata") SELECT "id", "type", COALESCE("content", 'Untitled'), "content", "created_at", "created_at", "filed_at", "metadata" FROM inbox_items; + +DROP TABLE inbox_items; + +ALTER TABLE __new_inbox_items RENAME TO inbox_items; + +PRAGMA foreign_keys=ON; + +CREATE INDEX idx_inbox_items_type ON inbox_items (type); +CREATE INDEX idx_inbox_items_created ON inbox_items (created_at); +CREATE INDEX idx_inbox_items_filed ON inbox_items (filed_at); +CREATE INDEX idx_inbox_items_snoozed ON inbox_items (snoozed_until); +CREATE INDEX idx_inbox_items_processing ON inbox_items (processing_status); +CREATE INDEX idx_inbox_items_archived ON inbox_items (archived_at); diff --git a/apps/desktop-tauri/src-tauri/migrations/0003_shallow_gladiator.sql b/apps/desktop-tauri/src-tauri/migrations/0003_shallow_gladiator.sql index 463109021..a7891845d 100644 --- a/apps/desktop-tauri/src-tauri/migrations/0003_shallow_gladiator.sql +++ b/apps/desktop-tauri/src-tauri/migrations/0003_shallow_gladiator.sql @@ -1 +1,19 @@ --- placeholder; real content lands in Phase B +-- Port of apps/desktop/src/main/database/drizzle-data/0003_shallow_gladiator.sql +-- Drizzle `--> statement-breakpoint` markers stripped; identifiers unbacktick'd. + +CREATE TABLE suggestion_feedback ( + id text PRIMARY KEY NOT NULL, + item_id text NOT NULL, + item_type text NOT NULL, + suggested_to text NOT NULL, + actual_to text NOT NULL, + accepted integer NOT NULL, + confidence integer NOT NULL, + suggested_tags text, + actual_tags text, + created_at text DEFAULT (datetime('now')) NOT NULL +); + +CREATE INDEX idx_suggestion_feedback_item_type ON suggestion_feedback (item_type); +CREATE INDEX idx_suggestion_feedback_accepted ON suggestion_feedback (accepted); +CREATE INDEX idx_suggestion_feedback_created ON suggestion_feedback (created_at); diff --git a/apps/desktop-tauri/src-tauri/migrations/0004_odd_silver_sable.sql b/apps/desktop-tauri/src-tauri/migrations/0004_odd_silver_sable.sql index 463109021..31cf0e24e 100644 --- a/apps/desktop-tauri/src-tauri/migrations/0004_odd_silver_sable.sql +++ b/apps/desktop-tauri/src-tauri/migrations/0004_odd_silver_sable.sql @@ -1 +1,24 @@ --- placeholder; real content lands in Phase B +-- Port of apps/desktop/src/main/database/drizzle-data/0004_odd_silver_sable.sql +-- Drizzle `--> statement-breakpoint` markers stripped; identifiers unbacktick'd. + +CREATE TABLE reminders ( + id text PRIMARY KEY NOT NULL, + target_type text NOT NULL, + target_id text NOT NULL, + remind_at text NOT NULL, + highlight_text text, + highlight_start integer, + highlight_end integer, + title text, + note text, + status text DEFAULT 'pending' NOT NULL, + triggered_at text, + dismissed_at text, + snoozed_until text, + created_at text DEFAULT (datetime('now')) NOT NULL, + modified_at text DEFAULT (datetime('now')) NOT NULL +); + +CREATE INDEX idx_reminders_target ON reminders (target_type, target_id); +CREATE INDEX idx_reminders_remind_at ON reminders (remind_at); +CREATE INDEX idx_reminders_status ON reminders (status); From 13249ed3ab01da05ab68dbc323d1dae8f1da8f24 Mon Sep 17 00:00:00 2001 From: Kaan Karaca Date: Sat, 25 Apr 2026 03:15:25 +0300 Subject: [PATCH 06/25] m2(migrations): port 0005-0009 (inbox alters, note_positions, tag_definitions, sync_devices/queue/state/history) --- .../migrations/0005_old_mac_gargan.sql | 7 ++- .../migrations/0006_late_infant_terrible.sql | 12 ++++- .../migrations/0007_safe_sunspot.sql | 9 +++- .../migrations/0008_blushing_magma.sql | 45 ++++++++++++++++++- .../migrations/0009_lumpy_gladiator.sql | 28 +++++++++++- 5 files changed, 96 insertions(+), 5 deletions(-) diff --git a/apps/desktop-tauri/src-tauri/migrations/0005_old_mac_gargan.sql b/apps/desktop-tauri/src-tauri/migrations/0005_old_mac_gargan.sql index 463109021..f1a1d3398 100644 --- a/apps/desktop-tauri/src-tauri/migrations/0005_old_mac_gargan.sql +++ b/apps/desktop-tauri/src-tauri/migrations/0005_old_mac_gargan.sql @@ -1 +1,6 @@ --- placeholder; real content lands in Phase B +-- Port of apps/desktop/src/main/database/drizzle-data/0005_old_mac_gargan.sql +-- Drizzle `--> statement-breakpoint` markers stripped; identifiers unbacktick'd. + +ALTER TABLE inbox_items ADD viewed_at text; + +ALTER TABLE inbox_stats ADD capture_count_reminder integer DEFAULT 0; diff --git a/apps/desktop-tauri/src-tauri/migrations/0006_late_infant_terrible.sql b/apps/desktop-tauri/src-tauri/migrations/0006_late_infant_terrible.sql index 463109021..55e7d52a3 100644 --- a/apps/desktop-tauri/src-tauri/migrations/0006_late_infant_terrible.sql +++ b/apps/desktop-tauri/src-tauri/migrations/0006_late_infant_terrible.sql @@ -1 +1,11 @@ --- placeholder; real content lands in Phase B +-- Port of apps/desktop/src/main/database/drizzle-data/0006_late_infant_terrible.sql +-- Drizzle `--> statement-breakpoint` markers stripped; identifiers unbacktick'd. + +CREATE TABLE note_positions ( + path text PRIMARY KEY NOT NULL, + folder_path text NOT NULL, + position integer DEFAULT 0 NOT NULL +); + +CREATE INDEX idx_note_positions_folder ON note_positions (folder_path); +CREATE INDEX idx_note_positions_order ON note_positions (folder_path, position); diff --git a/apps/desktop-tauri/src-tauri/migrations/0007_safe_sunspot.sql b/apps/desktop-tauri/src-tauri/migrations/0007_safe_sunspot.sql index 463109021..97fe9c99f 100644 --- a/apps/desktop-tauri/src-tauri/migrations/0007_safe_sunspot.sql +++ b/apps/desktop-tauri/src-tauri/migrations/0007_safe_sunspot.sql @@ -1 +1,8 @@ --- placeholder; real content lands in Phase B +-- Port of apps/desktop/src/main/database/drizzle-data/0007_safe_sunspot.sql +-- Identifiers unbacktick'd. + +CREATE TABLE tag_definitions ( + name text PRIMARY KEY NOT NULL, + color text NOT NULL, + created_at text DEFAULT (datetime('now')) NOT NULL +); diff --git a/apps/desktop-tauri/src-tauri/migrations/0008_blushing_magma.sql b/apps/desktop-tauri/src-tauri/migrations/0008_blushing_magma.sql index 463109021..885bb591e 100644 --- a/apps/desktop-tauri/src-tauri/migrations/0008_blushing_magma.sql +++ b/apps/desktop-tauri/src-tauri/migrations/0008_blushing_magma.sql @@ -1 +1,44 @@ --- placeholder; real content lands in Phase B +-- Port of apps/desktop/src/main/database/drizzle-data/0008_blushing_magma.sql +-- Drizzle `--> statement-breakpoint` markers stripped; identifiers unbacktick'd. + +CREATE TABLE sync_devices ( + id text PRIMARY KEY NOT NULL, + name text NOT NULL, + platform text NOT NULL, + os_version text, + app_version text NOT NULL, + linked_at integer NOT NULL, + last_sync_at integer, + is_current_device integer DEFAULT 0 NOT NULL +); + +CREATE TABLE sync_queue ( + id text PRIMARY KEY NOT NULL, + type text NOT NULL, + item_id text NOT NULL, + operation text NOT NULL, + payload text NOT NULL, + priority integer DEFAULT 0 NOT NULL, + attempts integer DEFAULT 0 NOT NULL, + last_attempt integer, + error_message text, + created_at integer NOT NULL +); + +CREATE TABLE sync_state ( + key text PRIMARY KEY NOT NULL, + value text NOT NULL, + updated_at integer NOT NULL +); + +CREATE TABLE sync_history ( + id text PRIMARY KEY NOT NULL, + type text NOT NULL, + item_count integer NOT NULL, + direction text, + details text, + duration_ms integer, + created_at integer NOT NULL +); + +CREATE INDEX idx_sync_history_created ON sync_history (created_at); diff --git a/apps/desktop-tauri/src-tauri/migrations/0009_lumpy_gladiator.sql b/apps/desktop-tauri/src-tauri/migrations/0009_lumpy_gladiator.sql index 463109021..87381bc0b 100644 --- a/apps/desktop-tauri/src-tauri/migrations/0009_lumpy_gladiator.sql +++ b/apps/desktop-tauri/src-tauri/migrations/0009_lumpy_gladiator.sql @@ -1 +1,27 @@ --- placeholder; real content lands in Phase B +-- Port of apps/desktop/src/main/database/drizzle-data/0009_lumpy_gladiator.sql +-- Drizzle `--> statement-breakpoint` markers stripped; identifiers unbacktick'd; +-- boolean DEFAULT literal `false` normalized to integer 0. + +PRAGMA foreign_keys=OFF; + +CREATE TABLE __new_sync_devices ( + id text PRIMARY KEY NOT NULL, + name text NOT NULL, + platform text NOT NULL, + os_version text, + app_version text NOT NULL, + linked_at integer NOT NULL, + last_sync_at integer, + is_current_device integer DEFAULT 0 NOT NULL +); + +INSERT INTO __new_sync_devices("id", "name", "platform", "os_version", "app_version", "linked_at", "last_sync_at", "is_current_device") SELECT "id", "name", "platform", "os_version", "app_version", "linked_at", "last_sync_at", "is_current_device" FROM sync_devices; + +DROP TABLE sync_devices; + +ALTER TABLE __new_sync_devices RENAME TO sync_devices; + +PRAGMA foreign_keys=ON; + +CREATE INDEX idx_sync_queue_type ON sync_queue (type); +CREATE INDEX idx_sync_queue_created ON sync_queue (created_at); From 2d3713e74511ff180197e45481b0f0b958410884 Mon Sep 17 00:00:00 2001 From: Kaan Karaca Date: Sat, 25 Apr 2026 03:16:44 +0300 Subject: [PATCH 07/25] m2(migrations): port 0010-0014 (sync clocks on tasks/inbox/saved_filters, signing_public_key, current_device unique index) --- .../0010_dizzy_natasha_romanoff.sql | 6 ++++- .../migrations/0011_silent_shooting_star.sql | 10 ++++++- .../src-tauri/migrations/0012_lush_veda.sql | 5 +++- .../migrations/0013_last_guardian.sql | 26 ++++++++++++++++++- .../migrations/0014_dazzling_leopardon.sql | 5 +++- 5 files changed, 47 insertions(+), 5 deletions(-) diff --git a/apps/desktop-tauri/src-tauri/migrations/0010_dizzy_natasha_romanoff.sql b/apps/desktop-tauri/src-tauri/migrations/0010_dizzy_natasha_romanoff.sql index 463109021..e8680644b 100644 --- a/apps/desktop-tauri/src-tauri/migrations/0010_dizzy_natasha_romanoff.sql +++ b/apps/desktop-tauri/src-tauri/migrations/0010_dizzy_natasha_romanoff.sql @@ -1 +1,5 @@ --- placeholder; real content lands in Phase B +-- Port of apps/desktop/src/main/database/drizzle-data/0010_dizzy_natasha_romanoff.sql +-- Drizzle `--> statement-breakpoint` markers stripped; identifiers unbacktick'd. + +ALTER TABLE tasks ADD clock text; +ALTER TABLE tasks ADD synced_at text; diff --git a/apps/desktop-tauri/src-tauri/migrations/0011_silent_shooting_star.sql b/apps/desktop-tauri/src-tauri/migrations/0011_silent_shooting_star.sql index 463109021..977818537 100644 --- a/apps/desktop-tauri/src-tauri/migrations/0011_silent_shooting_star.sql +++ b/apps/desktop-tauri/src-tauri/migrations/0011_silent_shooting_star.sql @@ -1 +1,9 @@ --- placeholder; real content lands in Phase B +-- Port of apps/desktop/src/main/database/drizzle-data/0011_silent_shooting_star.sql +-- Drizzle `--> statement-breakpoint` markers stripped; identifiers unbacktick'd; +-- boolean DEFAULT literal `false` normalized to integer 0. + +ALTER TABLE inbox_items ADD clock text; +ALTER TABLE inbox_items ADD synced_at text; +ALTER TABLE inbox_items ADD local_only integer DEFAULT 0; +ALTER TABLE saved_filters ADD clock text; +ALTER TABLE saved_filters ADD synced_at text; diff --git a/apps/desktop-tauri/src-tauri/migrations/0012_lush_veda.sql b/apps/desktop-tauri/src-tauri/migrations/0012_lush_veda.sql index 463109021..cb70ae964 100644 --- a/apps/desktop-tauri/src-tauri/migrations/0012_lush_veda.sql +++ b/apps/desktop-tauri/src-tauri/migrations/0012_lush_veda.sql @@ -1 +1,4 @@ --- placeholder; real content lands in Phase B +-- Port of apps/desktop/src/main/database/drizzle-data/0012_lush_veda.sql +-- Identifiers unbacktick'd. + +ALTER TABLE sync_devices ADD signing_public_key text; diff --git a/apps/desktop-tauri/src-tauri/migrations/0013_last_guardian.sql b/apps/desktop-tauri/src-tauri/migrations/0013_last_guardian.sql index 463109021..92be7e729 100644 --- a/apps/desktop-tauri/src-tauri/migrations/0013_last_guardian.sql +++ b/apps/desktop-tauri/src-tauri/migrations/0013_last_guardian.sql @@ -1 +1,25 @@ --- placeholder; real content lands in Phase B +-- Port of apps/desktop/src/main/database/drizzle-data/0013_last_guardian.sql +-- Drizzle `--> statement-breakpoint` markers stripped; identifiers unbacktick'd; +-- boolean DEFAULT literal `false` normalized to integer 0. + +PRAGMA foreign_keys=OFF; + +CREATE TABLE __new_sync_devices ( + id text PRIMARY KEY NOT NULL, + name text NOT NULL, + platform text NOT NULL, + os_version text, + app_version text NOT NULL, + linked_at integer NOT NULL, + last_sync_at integer, + is_current_device integer DEFAULT 0 NOT NULL, + signing_public_key text NOT NULL +); + +INSERT INTO __new_sync_devices("id", "name", "platform", "os_version", "app_version", "linked_at", "last_sync_at", "is_current_device", "signing_public_key") SELECT "id", "name", "platform", "os_version", "app_version", "linked_at", "last_sync_at", "is_current_device", "signing_public_key" FROM sync_devices; + +DROP TABLE sync_devices; + +ALTER TABLE __new_sync_devices RENAME TO sync_devices; + +PRAGMA foreign_keys=ON; diff --git a/apps/desktop-tauri/src-tauri/migrations/0014_dazzling_leopardon.sql b/apps/desktop-tauri/src-tauri/migrations/0014_dazzling_leopardon.sql index 463109021..9621af55c 100644 --- a/apps/desktop-tauri/src-tauri/migrations/0014_dazzling_leopardon.sql +++ b/apps/desktop-tauri/src-tauri/migrations/0014_dazzling_leopardon.sql @@ -1 +1,4 @@ --- placeholder; real content lands in Phase B +-- Port of apps/desktop/src/main/database/drizzle-data/0014_dazzling_leopardon.sql +-- Identifiers unbacktick'd. + +CREATE UNIQUE INDEX idx_unique_current_device ON sync_devices (is_current_device) WHERE is_current_device = 1; From ae5032947ccb7ca2c2998f31d68435fda7442bf0 Mon Sep 17 00:00:00 2001 From: Kaan Karaca Date: Sat, 25 Apr 2026 03:18:51 +0300 Subject: [PATCH 08/25] m2(migrations): port 0015-0019 (project/tag clocks, field_clocks, recent_searches + table rebuilds, capture_source) --- .../src-tauri/migrations/0015_brief_hex.sql | 6 +- .../migrations/0016_lovely_mastermind.sql | 5 +- .../migrations/0017_spotty_mongu.sql | 7 +- .../0018_greedy_stepford_cuckoos.sql | 300 +++++++++++++++++- .../0019_material_lethal_legion.sql | 5 +- 5 files changed, 318 insertions(+), 5 deletions(-) diff --git a/apps/desktop-tauri/src-tauri/migrations/0015_brief_hex.sql b/apps/desktop-tauri/src-tauri/migrations/0015_brief_hex.sql index 463109021..e2c97586b 100644 --- a/apps/desktop-tauri/src-tauri/migrations/0015_brief_hex.sql +++ b/apps/desktop-tauri/src-tauri/migrations/0015_brief_hex.sql @@ -1 +1,5 @@ --- placeholder; real content lands in Phase B +-- Port of apps/desktop/src/main/database/drizzle-data/0015_brief_hex.sql +-- Drizzle `--> statement-breakpoint` markers stripped; identifiers unbacktick'd. + +ALTER TABLE projects ADD clock text; +ALTER TABLE projects ADD synced_at text; diff --git a/apps/desktop-tauri/src-tauri/migrations/0016_lovely_mastermind.sql b/apps/desktop-tauri/src-tauri/migrations/0016_lovely_mastermind.sql index 463109021..c7e58b270 100644 --- a/apps/desktop-tauri/src-tauri/migrations/0016_lovely_mastermind.sql +++ b/apps/desktop-tauri/src-tauri/migrations/0016_lovely_mastermind.sql @@ -1 +1,4 @@ --- placeholder; real content lands in Phase B +-- Port of apps/desktop/src/main/database/drizzle-data/0016_lovely_mastermind.sql +-- Identifiers unbacktick'd. + +ALTER TABLE tag_definitions ADD clock text; diff --git a/apps/desktop-tauri/src-tauri/migrations/0017_spotty_mongu.sql b/apps/desktop-tauri/src-tauri/migrations/0017_spotty_mongu.sql index 463109021..6f2110fce 100644 --- a/apps/desktop-tauri/src-tauri/migrations/0017_spotty_mongu.sql +++ b/apps/desktop-tauri/src-tauri/migrations/0017_spotty_mongu.sql @@ -1 +1,6 @@ --- placeholder; real content lands in Phase B +-- Port of apps/desktop/src/main/database/drizzle-data/0017_spotty_mongu.sql +-- Drizzle `--> statement-breakpoint` markers stripped; identifiers unbacktick'd. +-- Phase 8 field-level vector clocks: adds field_clocks JSON column to projects + tasks. + +ALTER TABLE projects ADD field_clocks text; +ALTER TABLE tasks ADD field_clocks text; diff --git a/apps/desktop-tauri/src-tauri/migrations/0018_greedy_stepford_cuckoos.sql b/apps/desktop-tauri/src-tauri/migrations/0018_greedy_stepford_cuckoos.sql index 463109021..73ea45679 100644 --- a/apps/desktop-tauri/src-tauri/migrations/0018_greedy_stepford_cuckoos.sql +++ b/apps/desktop-tauri/src-tauri/migrations/0018_greedy_stepford_cuckoos.sql @@ -1 +1,299 @@ --- placeholder; real content lands in Phase B +-- Port of apps/desktop/src/main/database/drizzle-data/0018_greedy_stepford_cuckoos.sql +-- Drizzle `--> statement-breakpoint` markers stripped; identifiers unbacktick'd; +-- boolean DEFAULT literal `false` normalized to integer 0. +-- Massive table-rebuild migration: adds recent_searches; switches default +-- timestamp expression from datetime('now') to strftime('%Y-%m-%dT%H:%M:%fZ', 'now'); +-- backfills sync columns (clock/field_clocks/synced_at) on remaining tables. + +CREATE TABLE recent_searches ( + id text PRIMARY KEY NOT NULL, + query text NOT NULL, + result_count integer DEFAULT 0 NOT NULL, + searched_at text DEFAULT (strftime('%Y-%m-%dT%H:%M:%fZ', 'now')) NOT NULL +); + +PRAGMA foreign_keys=OFF; + +CREATE TABLE __new_projects ( + id text PRIMARY KEY NOT NULL, + name text NOT NULL, + description text, + color text DEFAULT '#6366f1' NOT NULL, + icon text, + position integer DEFAULT 0 NOT NULL, + is_inbox integer DEFAULT 0 NOT NULL, + created_at text DEFAULT (strftime('%Y-%m-%dT%H:%M:%fZ', 'now')) NOT NULL, + modified_at text DEFAULT (strftime('%Y-%m-%dT%H:%M:%fZ', 'now')) NOT NULL, + archived_at text, + clock text, + field_clocks text, + synced_at text +); + +INSERT INTO __new_projects("id", "name", "description", "color", "icon", "position", "is_inbox", "created_at", "modified_at", "archived_at", "clock", "field_clocks", "synced_at") SELECT "id", "name", "description", "color", "icon", "position", "is_inbox", "created_at", "modified_at", "archived_at", "clock", "field_clocks", "synced_at" FROM projects; + +DROP TABLE projects; + +ALTER TABLE __new_projects RENAME TO projects; + +PRAGMA foreign_keys=ON; + +CREATE TABLE __new_statuses ( + id text PRIMARY KEY NOT NULL, + project_id text NOT NULL, + name text NOT NULL, + color text DEFAULT '#6b7280' NOT NULL, + position integer DEFAULT 0 NOT NULL, + is_default integer DEFAULT 0 NOT NULL, + is_done integer DEFAULT 0 NOT NULL, + created_at text DEFAULT (strftime('%Y-%m-%dT%H:%M:%fZ', 'now')) NOT NULL, + FOREIGN KEY (project_id) REFERENCES projects(id) ON UPDATE no action ON DELETE cascade +); + +INSERT INTO __new_statuses("id", "project_id", "name", "color", "position", "is_default", "is_done", "created_at") SELECT "id", "project_id", "name", "color", "position", "is_default", "is_done", "created_at" FROM statuses; + +DROP TABLE statuses; + +ALTER TABLE __new_statuses RENAME TO statuses; + +CREATE INDEX idx_statuses_project ON statuses (project_id); + +CREATE TABLE __new_tasks ( + id text PRIMARY KEY NOT NULL, + project_id text NOT NULL, + status_id text, + parent_id text, + title text NOT NULL, + description text, + priority integer DEFAULT 0 NOT NULL, + position integer DEFAULT 0 NOT NULL, + due_date text, + due_time text, + start_date text, + repeat_config text, + repeat_from text, + source_note_id text, + completed_at text, + archived_at text, + clock text, + field_clocks text, + synced_at text, + created_at text DEFAULT (strftime('%Y-%m-%dT%H:%M:%fZ', 'now')) NOT NULL, + modified_at text DEFAULT (strftime('%Y-%m-%dT%H:%M:%fZ', 'now')) NOT NULL, + FOREIGN KEY (project_id) REFERENCES projects(id) ON UPDATE no action ON DELETE cascade, + FOREIGN KEY (status_id) REFERENCES statuses(id) ON UPDATE no action ON DELETE set null +); + +INSERT INTO __new_tasks("id", "project_id", "status_id", "parent_id", "title", "description", "priority", "position", "due_date", "due_time", "start_date", "repeat_config", "repeat_from", "source_note_id", "completed_at", "archived_at", "clock", "field_clocks", "synced_at", "created_at", "modified_at") SELECT "id", "project_id", "status_id", "parent_id", "title", "description", "priority", "position", "due_date", "due_time", "start_date", "repeat_config", "repeat_from", "source_note_id", "completed_at", "archived_at", "clock", "field_clocks", "synced_at", "created_at", "modified_at" FROM tasks; + +DROP TABLE tasks; + +ALTER TABLE __new_tasks RENAME TO tasks; + +CREATE INDEX idx_tasks_project ON tasks (project_id); +CREATE INDEX idx_tasks_status ON tasks (status_id); +CREATE INDEX idx_tasks_parent ON tasks (parent_id); +CREATE INDEX idx_tasks_due_date ON tasks (due_date); +CREATE INDEX idx_tasks_completed ON tasks (completed_at); + +CREATE TABLE __new_task_notes ( + task_id text NOT NULL, + note_id text NOT NULL, + created_at text DEFAULT (strftime('%Y-%m-%dT%H:%M:%fZ', 'now')) NOT NULL, + PRIMARY KEY(task_id, note_id), + FOREIGN KEY (task_id) REFERENCES tasks(id) ON UPDATE no action ON DELETE cascade +); + +INSERT INTO __new_task_notes("task_id", "note_id", "created_at") SELECT "task_id", "note_id", "created_at" FROM task_notes; + +DROP TABLE task_notes; + +ALTER TABLE __new_task_notes RENAME TO task_notes; + +CREATE TABLE __new_filing_history ( + id text PRIMARY KEY NOT NULL, + item_type text NOT NULL, + item_content text, + filed_to text NOT NULL, + filed_action text NOT NULL, + tags text, + filed_at text DEFAULT (strftime('%Y-%m-%dT%H:%M:%fZ', 'now')) NOT NULL +); + +INSERT INTO __new_filing_history("id", "item_type", "item_content", "filed_to", "filed_action", "tags", "filed_at") SELECT "id", "item_type", "item_content", "filed_to", "filed_action", "tags", "filed_at" FROM filing_history; + +DROP TABLE filing_history; + +ALTER TABLE __new_filing_history RENAME TO filing_history; + +CREATE INDEX idx_filing_history_type ON filing_history (item_type); +CREATE INDEX idx_filing_history_filed_at ON filing_history (filed_at); + +CREATE TABLE __new_inbox_item_tags ( + id text PRIMARY KEY NOT NULL, + item_id text NOT NULL, + tag text NOT NULL, + created_at text DEFAULT (strftime('%Y-%m-%dT%H:%M:%fZ', 'now')) NOT NULL, + FOREIGN KEY (item_id) REFERENCES inbox_items(id) ON UPDATE no action ON DELETE cascade +); + +INSERT INTO __new_inbox_item_tags("id", "item_id", "tag", "created_at") SELECT "id", "item_id", "tag", "created_at" FROM inbox_item_tags; + +DROP TABLE inbox_item_tags; + +ALTER TABLE __new_inbox_item_tags RENAME TO inbox_item_tags; + +CREATE INDEX idx_inbox_tags_item ON inbox_item_tags (item_id); +CREATE INDEX idx_inbox_tags_tag ON inbox_item_tags (tag); + +CREATE TABLE __new_inbox_items ( + id text PRIMARY KEY NOT NULL, + type text NOT NULL, + title text NOT NULL, + content text, + created_at text DEFAULT (strftime('%Y-%m-%dT%H:%M:%fZ', 'now')) NOT NULL, + modified_at text DEFAULT (strftime('%Y-%m-%dT%H:%M:%fZ', 'now')) NOT NULL, + filed_at text, + filed_to text, + filed_action text, + snoozed_until text, + snooze_reason text, + viewed_at text, + processing_status text DEFAULT 'complete', + processing_error text, + metadata text, + attachment_path text, + thumbnail_path text, + transcription text, + transcription_status text, + source_url text, + source_title text, + archived_at text, + clock text, + synced_at text, + local_only integer DEFAULT 0 +); + +INSERT INTO __new_inbox_items("id", "type", "title", "content", "created_at", "modified_at", "filed_at", "filed_to", "filed_action", "snoozed_until", "snooze_reason", "viewed_at", "processing_status", "processing_error", "metadata", "attachment_path", "thumbnail_path", "transcription", "transcription_status", "source_url", "source_title", "archived_at", "clock", "synced_at", "local_only") SELECT "id", "type", "title", "content", "created_at", "modified_at", "filed_at", "filed_to", "filed_action", "snoozed_until", "snooze_reason", "viewed_at", "processing_status", "processing_error", "metadata", "attachment_path", "thumbnail_path", "transcription", "transcription_status", "source_url", "source_title", "archived_at", "clock", "synced_at", "local_only" FROM inbox_items; + +DROP TABLE inbox_items; + +ALTER TABLE __new_inbox_items RENAME TO inbox_items; + +CREATE INDEX idx_inbox_items_type ON inbox_items (type); +CREATE INDEX idx_inbox_items_created ON inbox_items (created_at); +CREATE INDEX idx_inbox_items_filed ON inbox_items (filed_at); +CREATE INDEX idx_inbox_items_snoozed ON inbox_items (snoozed_until); +CREATE INDEX idx_inbox_items_processing ON inbox_items (processing_status); +CREATE INDEX idx_inbox_items_archived ON inbox_items (archived_at); + +CREATE TABLE __new_suggestion_feedback ( + id text PRIMARY KEY NOT NULL, + item_id text NOT NULL, + item_type text NOT NULL, + suggested_to text NOT NULL, + actual_to text NOT NULL, + accepted integer NOT NULL, + confidence integer NOT NULL, + suggested_tags text, + actual_tags text, + created_at text DEFAULT (strftime('%Y-%m-%dT%H:%M:%fZ', 'now')) NOT NULL +); + +INSERT INTO __new_suggestion_feedback("id", "item_id", "item_type", "suggested_to", "actual_to", "accepted", "confidence", "suggested_tags", "actual_tags", "created_at") SELECT "id", "item_id", "item_type", "suggested_to", "actual_to", "accepted", "confidence", "suggested_tags", "actual_tags", "created_at" FROM suggestion_feedback; + +DROP TABLE suggestion_feedback; + +ALTER TABLE __new_suggestion_feedback RENAME TO suggestion_feedback; + +CREATE INDEX idx_suggestion_feedback_item_type ON suggestion_feedback (item_type); +CREATE INDEX idx_suggestion_feedback_accepted ON suggestion_feedback (accepted); +CREATE INDEX idx_suggestion_feedback_created ON suggestion_feedback (created_at); + +CREATE TABLE __new_saved_filters ( + id text PRIMARY KEY NOT NULL, + name text NOT NULL, + config text NOT NULL, + position integer DEFAULT 0 NOT NULL, + created_at text DEFAULT (strftime('%Y-%m-%dT%H:%M:%fZ', 'now')) NOT NULL, + clock text, + synced_at text +); + +INSERT INTO __new_saved_filters("id", "name", "config", "position", "created_at", "clock", "synced_at") SELECT "id", "name", "config", "position", "created_at", "clock", "synced_at" FROM saved_filters; + +DROP TABLE saved_filters; + +ALTER TABLE __new_saved_filters RENAME TO saved_filters; + +CREATE TABLE __new_settings ( + key text PRIMARY KEY NOT NULL, + value text NOT NULL, + modified_at text DEFAULT (strftime('%Y-%m-%dT%H:%M:%fZ', 'now')) NOT NULL +); + +INSERT INTO __new_settings("key", "value", "modified_at") SELECT "key", "value", "modified_at" FROM settings; + +DROP TABLE settings; + +ALTER TABLE __new_settings RENAME TO settings; + +CREATE TABLE __new_bookmarks ( + id text PRIMARY KEY NOT NULL, + item_type text NOT NULL, + item_id text NOT NULL, + position integer DEFAULT 0 NOT NULL, + created_at text DEFAULT (strftime('%Y-%m-%dT%H:%M:%fZ', 'now')) NOT NULL +); + +INSERT INTO __new_bookmarks("id", "item_type", "item_id", "position", "created_at") SELECT "id", "item_type", "item_id", "position", "created_at" FROM bookmarks; + +DROP TABLE bookmarks; + +ALTER TABLE __new_bookmarks RENAME TO bookmarks; + +CREATE UNIQUE INDEX idx_bookmarks_unique_item ON bookmarks (item_type, item_id); +CREATE INDEX idx_bookmarks_item_type ON bookmarks (item_type); +CREATE INDEX idx_bookmarks_position ON bookmarks (position); +CREATE INDEX idx_bookmarks_created ON bookmarks (created_at); + +CREATE TABLE __new_reminders ( + id text PRIMARY KEY NOT NULL, + target_type text NOT NULL, + target_id text NOT NULL, + remind_at text NOT NULL, + highlight_text text, + highlight_start integer, + highlight_end integer, + title text, + note text, + status text DEFAULT 'pending' NOT NULL, + triggered_at text, + dismissed_at text, + snoozed_until text, + created_at text DEFAULT (strftime('%Y-%m-%dT%H:%M:%fZ', 'now')) NOT NULL, + modified_at text DEFAULT (strftime('%Y-%m-%dT%H:%M:%fZ', 'now')) NOT NULL +); + +INSERT INTO __new_reminders("id", "target_type", "target_id", "remind_at", "highlight_text", "highlight_start", "highlight_end", "title", "note", "status", "triggered_at", "dismissed_at", "snoozed_until", "created_at", "modified_at") SELECT "id", "target_type", "target_id", "remind_at", "highlight_text", "highlight_start", "highlight_end", "title", "note", "status", "triggered_at", "dismissed_at", "snoozed_until", "created_at", "modified_at" FROM reminders; + +DROP TABLE reminders; + +ALTER TABLE __new_reminders RENAME TO reminders; + +CREATE INDEX idx_reminders_target ON reminders (target_type, target_id); +CREATE INDEX idx_reminders_remind_at ON reminders (remind_at); +CREATE INDEX idx_reminders_status ON reminders (status); + +CREATE TABLE __new_tag_definitions ( + name text PRIMARY KEY NOT NULL, + color text NOT NULL, + clock text, + created_at text DEFAULT (strftime('%Y-%m-%dT%H:%M:%fZ', 'now')) NOT NULL +); + +INSERT INTO __new_tag_definitions("name", "color", "clock", "created_at") SELECT "name", "color", "clock", "created_at" FROM tag_definitions; + +DROP TABLE tag_definitions; + +ALTER TABLE __new_tag_definitions RENAME TO tag_definitions; diff --git a/apps/desktop-tauri/src-tauri/migrations/0019_material_lethal_legion.sql b/apps/desktop-tauri/src-tauri/migrations/0019_material_lethal_legion.sql index 463109021..833dc5bf6 100644 --- a/apps/desktop-tauri/src-tauri/migrations/0019_material_lethal_legion.sql +++ b/apps/desktop-tauri/src-tauri/migrations/0019_material_lethal_legion.sql @@ -1 +1,4 @@ --- placeholder; real content lands in Phase B +-- Port of apps/desktop/src/main/database/drizzle-data/0019_material_lethal_legion.sql +-- Identifiers unbacktick'd. + +ALTER TABLE inbox_items ADD capture_source text; From 96254193c0a9b2fb395b397b82993b88dbcc7d91 Mon Sep 17 00:00:00 2001 From: Kaan Karaca Date: Sat, 25 Apr 2026 03:21:11 +0300 Subject: [PATCH 09/25] m2(migrations): port 0020-0028 hand-written (search_reasons/inbox_jobs/note_metadata/property_definitions/folder_configs/calendar tables and alters) --- .../migrations/0020_search_reasons.sql | 19 ++- .../src-tauri/migrations/0021_inbox_jobs.sql | 29 ++++- .../migrations/0022_notes_journal_vault.sql | 42 ++++++- .../migrations/0023_folder_configs.sql | 11 +- .../0024_google_calendar_foundation.sql | 111 +++++++++++++++++- .../migrations/0025_event_target_calendar.sql | 5 +- .../migrations/0026_calendar_field_clocks.sql | 5 +- .../migrations/0027_calendar_rich_fields.sql | 17 ++- .../0028_calendar_source_last_error.sql | 5 +- 9 files changed, 235 insertions(+), 9 deletions(-) diff --git a/apps/desktop-tauri/src-tauri/migrations/0020_search_reasons.sql b/apps/desktop-tauri/src-tauri/migrations/0020_search_reasons.sql index 463109021..60469b30c 100644 --- a/apps/desktop-tauri/src-tauri/migrations/0020_search_reasons.sql +++ b/apps/desktop-tauri/src-tauri/migrations/0020_search_reasons.sql @@ -1 +1,18 @@ --- placeholder; real content lands in Phase B +-- Port of apps/desktop/src/main/database/drizzle-data/0020_search_reasons.sql +-- Hand-written Electron migration; identifiers unbacktick'd. + +DROP TABLE IF EXISTS recent_searches; + +CREATE TABLE search_reasons ( + id text PRIMARY KEY NOT NULL, + item_id text NOT NULL, + item_type text NOT NULL, + item_title text NOT NULL, + item_icon text, + search_query text NOT NULL, + visited_at text DEFAULT (strftime('%Y-%m-%dT%H:%M:%fZ', 'now')) NOT NULL +); + +CREATE UNIQUE INDEX idx_search_reasons_item ON search_reasons (item_type, item_id); + +CREATE INDEX idx_search_reasons_visited ON search_reasons (visited_at); diff --git a/apps/desktop-tauri/src-tauri/migrations/0021_inbox_jobs.sql b/apps/desktop-tauri/src-tauri/migrations/0021_inbox_jobs.sql index 463109021..bb7d32c70 100644 --- a/apps/desktop-tauri/src-tauri/migrations/0021_inbox_jobs.sql +++ b/apps/desktop-tauri/src-tauri/migrations/0021_inbox_jobs.sql @@ -1 +1,28 @@ --- placeholder; real content lands in Phase B +-- Port of apps/desktop/src/main/database/drizzle-data/0021_inbox_jobs.sql +-- Hand-written Electron migration; identifiers unbacktick'd. + +CREATE TABLE inbox_jobs ( + id text PRIMARY KEY NOT NULL, + item_id text NOT NULL, + type text NOT NULL, + status text DEFAULT 'pending' NOT NULL, + run_at text DEFAULT (strftime('%Y-%m-%dT%H:%M:%fZ', 'now')) NOT NULL, + attempts integer DEFAULT 0 NOT NULL, + max_attempts integer DEFAULT 1 NOT NULL, + payload text, + result text, + last_error text, + started_at text, + completed_at text, + created_at text DEFAULT (strftime('%Y-%m-%dT%H:%M:%fZ', 'now')) NOT NULL, + updated_at text DEFAULT (strftime('%Y-%m-%dT%H:%M:%fZ', 'now')) NOT NULL, + FOREIGN KEY (item_id) REFERENCES inbox_items(id) ON UPDATE no action ON DELETE cascade +); + +CREATE INDEX idx_inbox_jobs_item ON inbox_jobs (item_id); + +CREATE INDEX idx_inbox_jobs_status ON inbox_jobs (status); + +CREATE INDEX idx_inbox_jobs_run_at ON inbox_jobs (run_at); + +CREATE INDEX idx_inbox_jobs_item_type ON inbox_jobs (item_id, type); diff --git a/apps/desktop-tauri/src-tauri/migrations/0022_notes_journal_vault.sql b/apps/desktop-tauri/src-tauri/migrations/0022_notes_journal_vault.sql index 463109021..525899613 100644 --- a/apps/desktop-tauri/src-tauri/migrations/0022_notes_journal_vault.sql +++ b/apps/desktop-tauri/src-tauri/migrations/0022_notes_journal_vault.sql @@ -1 +1,41 @@ --- placeholder; real content lands in Phase B +-- Port of apps/desktop/src/main/database/drizzle-data/0022_notes_journal_vault.sql +-- Hand-written Electron migration; identifiers unbacktick'd; +-- boolean DEFAULT literal `false` normalized to integer 0. + +CREATE TABLE note_metadata ( + id text PRIMARY KEY NOT NULL, + path text NOT NULL, + title text NOT NULL, + emoji text, + file_type text DEFAULT 'markdown' NOT NULL, + mime_type text, + file_size integer, + attachment_id text, + attachment_references text, + local_only integer DEFAULT 0 NOT NULL, + sync_policy text DEFAULT 'sync' NOT NULL, + journal_date text, + property_definition_names text, + clock text, + synced_at text, + created_at text NOT NULL, + modified_at text NOT NULL, + stored_at text DEFAULT (strftime('%Y-%m-%dT%H:%M:%fZ', 'now')) NOT NULL +); + +CREATE UNIQUE INDEX idx_note_metadata_path ON note_metadata (path); + +CREATE INDEX idx_note_metadata_modified ON note_metadata (modified_at); + +CREATE INDEX idx_note_metadata_journal_date ON note_metadata (journal_date); + +CREATE INDEX idx_note_metadata_local_only ON note_metadata (local_only); + +CREATE TABLE property_definitions ( + name text PRIMARY KEY NOT NULL, + type text NOT NULL, + options text, + default_value text, + color text, + created_at text DEFAULT (strftime('%Y-%m-%dT%H:%M:%fZ', 'now')) NOT NULL +); diff --git a/apps/desktop-tauri/src-tauri/migrations/0023_folder_configs.sql b/apps/desktop-tauri/src-tauri/migrations/0023_folder_configs.sql index 463109021..8d920970d 100644 --- a/apps/desktop-tauri/src-tauri/migrations/0023_folder_configs.sql +++ b/apps/desktop-tauri/src-tauri/migrations/0023_folder_configs.sql @@ -1 +1,10 @@ --- placeholder; real content lands in Phase B +-- Port of apps/desktop/src/main/database/drizzle-data/0023_folder_configs.sql +-- Hand-written Electron migration; identifiers unbacktick'd. + +CREATE TABLE folder_configs ( + path text PRIMARY KEY NOT NULL, + icon text, + clock text, + created_at text DEFAULT (strftime('%Y-%m-%dT%H:%M:%fZ', 'now')) NOT NULL, + modified_at text DEFAULT (strftime('%Y-%m-%dT%H:%M:%fZ', 'now')) NOT NULL +); diff --git a/apps/desktop-tauri/src-tauri/migrations/0024_google_calendar_foundation.sql b/apps/desktop-tauri/src-tauri/migrations/0024_google_calendar_foundation.sql index 463109021..2df1e98ee 100644 --- a/apps/desktop-tauri/src-tauri/migrations/0024_google_calendar_foundation.sql +++ b/apps/desktop-tauri/src-tauri/migrations/0024_google_calendar_foundation.sql @@ -1 +1,110 @@ --- placeholder; real content lands in Phase B +-- Port of apps/desktop/src/main/database/drizzle-data/0024_google_calendar_foundation.sql +-- Hand-written Electron migration; Drizzle `--> statement-breakpoint` markers stripped; +-- identifiers unbacktick'd; boolean DEFAULT literal `false` normalized to integer 0. + +CREATE TABLE calendar_events ( + id text PRIMARY KEY NOT NULL, + title text NOT NULL, + description text, + location text, + start_at text NOT NULL, + end_at text, + timezone text DEFAULT 'UTC' NOT NULL, + is_all_day integer DEFAULT 0 NOT NULL, + recurrence_rule text, + recurrence_exceptions text, + archived_at text, + clock text, + synced_at text, + created_at text DEFAULT (strftime('%Y-%m-%dT%H:%M:%fZ', 'now')) NOT NULL, + modified_at text DEFAULT (strftime('%Y-%m-%dT%H:%M:%fZ', 'now')) NOT NULL +); + +CREATE INDEX idx_calendar_events_start_at ON calendar_events (start_at); + +CREATE INDEX idx_calendar_events_archived_at ON calendar_events (archived_at); + +CREATE TABLE calendar_sources ( + id text PRIMARY KEY NOT NULL, + provider text NOT NULL, + kind text NOT NULL, + account_id text, + remote_id text NOT NULL, + title text NOT NULL, + timezone text, + color text, + is_primary integer DEFAULT 0 NOT NULL, + is_selected integer DEFAULT 0 NOT NULL, + is_memry_managed integer DEFAULT 0 NOT NULL, + sync_cursor text, + sync_status text DEFAULT 'idle' NOT NULL, + last_synced_at text, + metadata text, + archived_at text, + clock text, + synced_at text, + created_at text DEFAULT (strftime('%Y-%m-%dT%H:%M:%fZ', 'now')) NOT NULL, + modified_at text DEFAULT (strftime('%Y-%m-%dT%H:%M:%fZ', 'now')) NOT NULL +); + +CREATE UNIQUE INDEX idx_calendar_sources_provider_remote ON calendar_sources (provider, kind, remote_id); + +CREATE INDEX idx_calendar_sources_account ON calendar_sources (account_id); + +CREATE INDEX idx_calendar_sources_selected ON calendar_sources (is_selected); + +CREATE TABLE calendar_external_events ( + id text PRIMARY KEY NOT NULL, + source_id text NOT NULL, + remote_event_id text NOT NULL, + remote_etag text, + remote_updated_at text, + title text NOT NULL, + description text, + location text, + start_at text NOT NULL, + end_at text, + timezone text, + is_all_day integer DEFAULT 0 NOT NULL, + status text DEFAULT 'confirmed' NOT NULL, + recurrence_rule text, + raw_payload text, + archived_at text, + clock text, + synced_at text, + created_at text DEFAULT (strftime('%Y-%m-%dT%H:%M:%fZ', 'now')) NOT NULL, + modified_at text DEFAULT (strftime('%Y-%m-%dT%H:%M:%fZ', 'now')) NOT NULL, + FOREIGN KEY (source_id) REFERENCES calendar_sources(id) ON UPDATE no action ON DELETE cascade +); + +CREATE UNIQUE INDEX idx_calendar_external_events_source_remote ON calendar_external_events (source_id, remote_event_id); + +CREATE INDEX idx_calendar_external_events_start_at ON calendar_external_events (start_at); + +CREATE INDEX idx_calendar_external_events_archived_at ON calendar_external_events (archived_at); + +CREATE TABLE calendar_bindings ( + id text PRIMARY KEY NOT NULL, + source_type text NOT NULL, + source_id text NOT NULL, + provider text NOT NULL, + remote_calendar_id text NOT NULL, + remote_event_id text NOT NULL, + ownership_mode text NOT NULL, + writeback_mode text NOT NULL, + remote_version text, + last_local_snapshot text, + archived_at text, + clock text, + synced_at text, + created_at text DEFAULT (strftime('%Y-%m-%dT%H:%M:%fZ', 'now')) NOT NULL, + modified_at text DEFAULT (strftime('%Y-%m-%dT%H:%M:%fZ', 'now')) NOT NULL +); + +CREATE UNIQUE INDEX idx_calendar_bindings_source ON calendar_bindings (source_type, source_id, provider); + +CREATE UNIQUE INDEX idx_calendar_bindings_remote ON calendar_bindings (provider, remote_calendar_id, remote_event_id); + +CREATE INDEX idx_calendar_bindings_source_type ON calendar_bindings (source_type); + +CREATE INDEX idx_calendar_bindings_archived_at ON calendar_bindings (archived_at); diff --git a/apps/desktop-tauri/src-tauri/migrations/0025_event_target_calendar.sql b/apps/desktop-tauri/src-tauri/migrations/0025_event_target_calendar.sql index 463109021..aa10abecc 100644 --- a/apps/desktop-tauri/src-tauri/migrations/0025_event_target_calendar.sql +++ b/apps/desktop-tauri/src-tauri/migrations/0025_event_target_calendar.sql @@ -1 +1,4 @@ --- placeholder; real content lands in Phase B +-- Port of apps/desktop/src/main/database/drizzle-data/0025_event_target_calendar.sql +-- Hand-written Electron migration; identifiers unbacktick'd. + +ALTER TABLE calendar_events ADD COLUMN target_calendar_id text; diff --git a/apps/desktop-tauri/src-tauri/migrations/0026_calendar_field_clocks.sql b/apps/desktop-tauri/src-tauri/migrations/0026_calendar_field_clocks.sql index 463109021..e2a18c03f 100644 --- a/apps/desktop-tauri/src-tauri/migrations/0026_calendar_field_clocks.sql +++ b/apps/desktop-tauri/src-tauri/migrations/0026_calendar_field_clocks.sql @@ -1 +1,4 @@ --- placeholder; real content lands in Phase B +-- Port of apps/desktop/src/main/database/drizzle-data/0026_calendar_field_clocks.sql +-- Hand-written Electron migration; identifiers unbacktick'd. + +ALTER TABLE calendar_events ADD COLUMN field_clocks text; diff --git a/apps/desktop-tauri/src-tauri/migrations/0027_calendar_rich_fields.sql b/apps/desktop-tauri/src-tauri/migrations/0027_calendar_rich_fields.sql index 463109021..69241f6fd 100644 --- a/apps/desktop-tauri/src-tauri/migrations/0027_calendar_rich_fields.sql +++ b/apps/desktop-tauri/src-tauri/migrations/0027_calendar_rich_fields.sql @@ -1 +1,16 @@ --- placeholder; real content lands in Phase B +-- Port of apps/desktop/src/main/database/drizzle-data/0027_calendar_rich_fields.sql +-- Hand-written Electron migration; Drizzle `--> statement-breakpoint` markers stripped; +-- identifiers unbacktick'd. + +ALTER TABLE calendar_events ADD COLUMN attendees text; +ALTER TABLE calendar_events ADD COLUMN reminders text; +ALTER TABLE calendar_events ADD COLUMN visibility text; +ALTER TABLE calendar_events ADD COLUMN color_id text; +ALTER TABLE calendar_events ADD COLUMN conference_data text; +ALTER TABLE calendar_events ADD COLUMN parent_event_id text; +ALTER TABLE calendar_events ADD COLUMN original_start_time text; +ALTER TABLE calendar_external_events ADD COLUMN attendees text; +ALTER TABLE calendar_external_events ADD COLUMN reminders text; +ALTER TABLE calendar_external_events ADD COLUMN visibility text; +ALTER TABLE calendar_external_events ADD COLUMN color_id text; +ALTER TABLE calendar_external_events ADD COLUMN conference_data text; diff --git a/apps/desktop-tauri/src-tauri/migrations/0028_calendar_source_last_error.sql b/apps/desktop-tauri/src-tauri/migrations/0028_calendar_source_last_error.sql index 463109021..8549334b5 100644 --- a/apps/desktop-tauri/src-tauri/migrations/0028_calendar_source_last_error.sql +++ b/apps/desktop-tauri/src-tauri/migrations/0028_calendar_source_last_error.sql @@ -1 +1,4 @@ --- placeholder; real content lands in Phase B +-- Port of apps/desktop/src/main/database/drizzle-data/0028_calendar_source_last_error.sql +-- Hand-written Electron migration; identifiers unbacktick'd. + +ALTER TABLE calendar_sources ADD COLUMN last_error text; From e07d488a5c3ae77674a54b0e64e23b172e22485d Mon Sep 17 00:00:00 2001 From: Kaan Karaca Date: Sat, 25 Apr 2026 03:22:01 +0300 Subject: [PATCH 10/25] m2(migrations): add full-apply integration tests (table set + field_clocks) --- .../src-tauri/tests/migrations_test.rs | 104 ++++++++++++++++++ 1 file changed, 104 insertions(+) diff --git a/apps/desktop-tauri/src-tauri/tests/migrations_test.rs b/apps/desktop-tauri/src-tauri/tests/migrations_test.rs index a688ad0dc..060693bff 100644 --- a/apps/desktop-tauri/src-tauri/tests/migrations_test.rs +++ b/apps/desktop-tauri/src-tauri/tests/migrations_test.rs @@ -83,3 +83,107 @@ fn migration_0000_creates_core_tables() { assert_eq!(exists, 1, "table {table} missing after migration 0000"); } } + +#[test] +fn full_migration_produces_expected_table_set() { + let mut conn = Connection::open_in_memory().unwrap(); + migrations::apply_pending(&mut conn).unwrap(); + + let mut stmt = conn + .prepare( + "SELECT name FROM sqlite_master \ + WHERE type='table' AND name NOT LIKE 'sqlite_%' \ + ORDER BY name", + ) + .unwrap(); + let tables: Vec = stmt + .query_map([], |row| row.get::<_, String>(0)) + .unwrap() + .filter_map(Result::ok) + .collect(); + + // Required tables traced to the migration that creates them (final state + // after all 29 ports apply). Any absence indicates a missing or wrongly + // ordered port. Update this list only if a port faithfully removed the + // table — never soften the assertion. + let required: &[&str] = &[ + // bootstrap + "schema_migrations", + // 0000 + "projects", + "statuses", + "tasks", + "task_notes", + "task_tags", + "inbox_items", + "saved_filters", + "settings", + // 0001 + "bookmarks", + // 0002 + "filing_history", + "inbox_item_tags", + "inbox_stats", + // 0003 + "suggestion_feedback", + // 0004 + "reminders", + // 0006 + "note_positions", + // 0007 + "tag_definitions", + // 0008 + "sync_devices", + "sync_queue", + "sync_state", + "sync_history", + // 0020 + "search_reasons", + // 0021 + "inbox_jobs", + // 0022 + "note_metadata", + "property_definitions", + // 0023 + "folder_configs", + // 0024 + "calendar_events", + "calendar_sources", + "calendar_external_events", + "calendar_bindings", + ]; + for name in required { + assert!( + tables.contains(&name.to_string()), + "required table {name} missing; present tables: {tables:?}" + ); + } + + // recent_searches was added in 0018 and dropped in 0020 — it MUST NOT + // remain in the final schema. Guards against accidentally re-adding it. + assert!( + !tables.contains(&"recent_searches".to_string()), + "recent_searches should have been dropped by 0020; present tables: {tables:?}" + ); +} + +#[test] +fn tasks_and_projects_have_field_clocks_column() { + let mut conn = Connection::open_in_memory().unwrap(); + migrations::apply_pending(&mut conn).unwrap(); + + for table in ["tasks", "projects"] { + let mut stmt = conn + .prepare(&format!("PRAGMA table_info({table})")) + .unwrap(); + let cols: Vec = stmt + .query_map([], |row| row.get::<_, String>(1)) + .unwrap() + .filter_map(Result::ok) + .collect(); + assert!( + cols.contains(&"field_clocks".to_string()), + "{table} missing field_clocks column; cols: {cols:?}" + ); + } +} From 91d8b016485c85c9ffb65c03ba04cfb70f67b8a5 Mon Sep 17 00:00:00 2001 From: Kaan Karaca Date: Sat, 25 Apr 2026 03:29:08 +0300 Subject: [PATCH 11/25] m2(db): add Project/Status/Task structs with from_row helpers Per-table domain structs derive specta::Type for Phase F binding generation. Project includes clock/synced_at to match the final schema after migrations 0015 + 0017 + 0018 (plan snippet elided them; SQL is authoritative). projects_and_tasks_roundtrip exercises INSERT + SELECT roundtrip via from_row for all three tables. --- apps/desktop-tauri/src-tauri/src/db/mod.rs | 4 ++ .../src-tauri/src/db/projects.rs | 39 ++++++++++++ .../src-tauri/src/db/statuses.rs | 29 +++++++++ apps/desktop-tauri/src-tauri/src/db/tasks.rs | 55 +++++++++++++++++ .../src-tauri/tests/migrations_test.rs | 59 +++++++++++++++++++ 5 files changed, 186 insertions(+) create mode 100644 apps/desktop-tauri/src-tauri/src/db/projects.rs create mode 100644 apps/desktop-tauri/src-tauri/src/db/statuses.rs create mode 100644 apps/desktop-tauri/src-tauri/src/db/tasks.rs diff --git a/apps/desktop-tauri/src-tauri/src/db/mod.rs b/apps/desktop-tauri/src-tauri/src/db/mod.rs index 5afebd427..42f7d0502 100644 --- a/apps/desktop-tauri/src-tauri/src/db/mod.rs +++ b/apps/desktop-tauri/src-tauri/src/db/mod.rs @@ -9,6 +9,10 @@ use std::{ pub mod migrations; +pub mod projects; +pub mod statuses; +pub mod tasks; + pub type DbGuard<'a> = MutexGuard<'a, Connection>; #[derive(Clone)] diff --git a/apps/desktop-tauri/src-tauri/src/db/projects.rs b/apps/desktop-tauri/src-tauri/src/db/projects.rs new file mode 100644 index 000000000..19c7d5742 --- /dev/null +++ b/apps/desktop-tauri/src-tauri/src/db/projects.rs @@ -0,0 +1,39 @@ +use serde::{Deserialize, Serialize}; + +#[derive(Debug, Clone, Serialize, Deserialize, specta::Type)] +#[serde(rename_all = "camelCase")] +pub struct Project { + pub id: String, + pub name: String, + pub description: Option, + pub color: String, + pub icon: Option, + pub position: i64, + pub is_inbox: bool, + pub created_at: String, + pub modified_at: String, + pub archived_at: Option, + pub clock: Option, + pub field_clocks: Option, + pub synced_at: Option, +} + +impl Project { + pub fn from_row(row: &rusqlite::Row<'_>) -> rusqlite::Result { + Ok(Self { + id: row.get("id")?, + name: row.get("name")?, + description: row.get("description")?, + color: row.get("color")?, + icon: row.get("icon")?, + position: row.get("position")?, + is_inbox: row.get::<_, i64>("is_inbox")? != 0, + created_at: row.get("created_at")?, + modified_at: row.get("modified_at")?, + archived_at: row.get("archived_at")?, + clock: row.get("clock")?, + field_clocks: row.get("field_clocks")?, + synced_at: row.get("synced_at")?, + }) + } +} diff --git a/apps/desktop-tauri/src-tauri/src/db/statuses.rs b/apps/desktop-tauri/src-tauri/src/db/statuses.rs new file mode 100644 index 000000000..b6f8b10e7 --- /dev/null +++ b/apps/desktop-tauri/src-tauri/src/db/statuses.rs @@ -0,0 +1,29 @@ +use serde::{Deserialize, Serialize}; + +#[derive(Debug, Clone, Serialize, Deserialize, specta::Type)] +#[serde(rename_all = "camelCase")] +pub struct Status { + pub id: String, + pub project_id: String, + pub name: String, + pub color: String, + pub position: i64, + pub is_default: bool, + pub is_done: bool, + pub created_at: String, +} + +impl Status { + pub fn from_row(row: &rusqlite::Row<'_>) -> rusqlite::Result { + Ok(Self { + id: row.get("id")?, + project_id: row.get("project_id")?, + name: row.get("name")?, + color: row.get("color")?, + position: row.get("position")?, + is_default: row.get::<_, i64>("is_default")? != 0, + is_done: row.get::<_, i64>("is_done")? != 0, + created_at: row.get("created_at")?, + }) + } +} diff --git a/apps/desktop-tauri/src-tauri/src/db/tasks.rs b/apps/desktop-tauri/src-tauri/src/db/tasks.rs new file mode 100644 index 000000000..a0addb373 --- /dev/null +++ b/apps/desktop-tauri/src-tauri/src/db/tasks.rs @@ -0,0 +1,55 @@ +use serde::{Deserialize, Serialize}; + +#[derive(Debug, Clone, Serialize, Deserialize, specta::Type)] +#[serde(rename_all = "camelCase")] +pub struct Task { + pub id: String, + pub project_id: String, + pub status_id: Option, + pub parent_id: Option, + pub title: String, + pub description: Option, + pub priority: i64, + pub position: i64, + pub due_date: Option, + pub due_time: Option, + pub start_date: Option, + pub repeat_config: Option, + pub repeat_from: Option, + pub source_note_id: Option, + pub completed_at: Option, + pub archived_at: Option, + pub clock: Option, + pub field_clocks: Option, + pub synced_at: Option, + pub created_at: String, + pub modified_at: String, +} + +impl Task { + pub fn from_row(row: &rusqlite::Row<'_>) -> rusqlite::Result { + Ok(Self { + id: row.get("id")?, + project_id: row.get("project_id")?, + status_id: row.get("status_id")?, + parent_id: row.get("parent_id")?, + title: row.get("title")?, + description: row.get("description")?, + priority: row.get("priority")?, + position: row.get("position")?, + due_date: row.get("due_date")?, + due_time: row.get("due_time")?, + start_date: row.get("start_date")?, + repeat_config: row.get("repeat_config")?, + repeat_from: row.get("repeat_from")?, + source_note_id: row.get("source_note_id")?, + completed_at: row.get("completed_at")?, + archived_at: row.get("archived_at")?, + clock: row.get("clock")?, + field_clocks: row.get("field_clocks")?, + synced_at: row.get("synced_at")?, + created_at: row.get("created_at")?, + modified_at: row.get("modified_at")?, + }) + } +} diff --git a/apps/desktop-tauri/src-tauri/tests/migrations_test.rs b/apps/desktop-tauri/src-tauri/tests/migrations_test.rs index 060693bff..f1ece2298 100644 --- a/apps/desktop-tauri/src-tauri/tests/migrations_test.rs +++ b/apps/desktop-tauri/src-tauri/tests/migrations_test.rs @@ -187,3 +187,62 @@ fn tasks_and_projects_have_field_clocks_column() { ); } } + +#[test] +fn projects_and_tasks_roundtrip() { + let db = memry_desktop_tauri_lib::db::Db::open_memory().unwrap(); + let conn = db.conn().unwrap(); + + conn.execute( + "INSERT INTO projects (id, name, color, position) VALUES (?1, ?2, ?3, ?4)", + rusqlite::params!["p1", "Inbox", "#000", 0], + ) + .unwrap(); + conn.execute( + "INSERT INTO statuses (id, project_id, name, color, position, is_default, is_done) \ + VALUES (?1, ?2, ?3, ?4, ?5, ?6, ?7)", + rusqlite::params!["s1", "p1", "Todo", "#abc", 0, 1, 0], + ) + .unwrap(); + conn.execute( + "INSERT INTO tasks (id, project_id, status_id, title, priority, position) \ + VALUES (?1, ?2, ?3, ?4, ?5, ?6)", + rusqlite::params!["t1", "p1", "s1", "first", 0, 0], + ) + .unwrap(); + + let project = conn + .query_row( + "SELECT * FROM projects WHERE id = 'p1'", + [], + memry_desktop_tauri_lib::db::projects::Project::from_row, + ) + .unwrap(); + assert_eq!(project.id, "p1"); + assert_eq!(project.name, "Inbox"); + assert!(!project.is_inbox); + + let status = conn + .query_row( + "SELECT * FROM statuses WHERE id = 's1'", + [], + memry_desktop_tauri_lib::db::statuses::Status::from_row, + ) + .unwrap(); + assert_eq!(status.project_id, "p1"); + assert!(status.is_default); + assert!(!status.is_done); + + let task = conn + .query_row( + "SELECT * FROM tasks WHERE id = 't1'", + [], + memry_desktop_tauri_lib::db::tasks::Task::from_row, + ) + .unwrap(); + assert_eq!(task.project_id, "p1"); + assert_eq!(task.status_id.as_deref(), Some("s1")); + assert_eq!(task.title, "first"); + assert!(task.clock.is_none()); + assert!(task.field_clocks.is_none()); +} From 328e4b10b0ea5b2c14e3522eade58a194b84a7f7 Mon Sep 17 00:00:00 2001 From: Kaan Karaca Date: Sat, 25 Apr 2026 03:31:03 +0300 Subject: [PATCH 12/25] m2(db): add NoteMetadata/NotePosition/PropertyDefinition structs Per-table domain structs for the note vault tables (0006 + 0022). Each derives specta::Type for Phase F binding generation. PropertyDefinition uses r#type with explicit serde(rename) since type is a Rust keyword; the DB column stays "type". One roundtrip smoke test per table covers INSERT + SELECT via from_row. --- apps/desktop-tauri/src-tauri/src/db/mod.rs | 3 + .../src-tauri/src/db/note_metadata.rs | 49 +++++++++++ .../src-tauri/src/db/note_positions.rs | 19 ++++ .../src-tauri/src/db/notes_cache.rs | 26 ++++++ .../src-tauri/tests/migrations_test.rs | 87 +++++++++++++++++++ 5 files changed, 184 insertions(+) create mode 100644 apps/desktop-tauri/src-tauri/src/db/note_metadata.rs create mode 100644 apps/desktop-tauri/src-tauri/src/db/note_positions.rs create mode 100644 apps/desktop-tauri/src-tauri/src/db/notes_cache.rs diff --git a/apps/desktop-tauri/src-tauri/src/db/mod.rs b/apps/desktop-tauri/src-tauri/src/db/mod.rs index 42f7d0502..040327e90 100644 --- a/apps/desktop-tauri/src-tauri/src/db/mod.rs +++ b/apps/desktop-tauri/src-tauri/src/db/mod.rs @@ -9,6 +9,9 @@ use std::{ pub mod migrations; +pub mod note_metadata; +pub mod note_positions; +pub mod notes_cache; pub mod projects; pub mod statuses; pub mod tasks; diff --git a/apps/desktop-tauri/src-tauri/src/db/note_metadata.rs b/apps/desktop-tauri/src-tauri/src/db/note_metadata.rs new file mode 100644 index 000000000..169877601 --- /dev/null +++ b/apps/desktop-tauri/src-tauri/src/db/note_metadata.rs @@ -0,0 +1,49 @@ +use serde::{Deserialize, Serialize}; + +#[derive(Debug, Clone, Serialize, Deserialize, specta::Type)] +#[serde(rename_all = "camelCase")] +pub struct NoteMetadata { + pub id: String, + pub path: String, + pub title: String, + pub emoji: Option, + pub file_type: String, + pub mime_type: Option, + pub file_size: Option, + pub attachment_id: Option, + pub attachment_references: Option, + pub local_only: bool, + pub sync_policy: String, + pub journal_date: Option, + pub property_definition_names: Option, + pub clock: Option, + pub synced_at: Option, + pub created_at: String, + pub modified_at: String, + pub stored_at: String, +} + +impl NoteMetadata { + pub fn from_row(row: &rusqlite::Row<'_>) -> rusqlite::Result { + Ok(Self { + id: row.get("id")?, + path: row.get("path")?, + title: row.get("title")?, + emoji: row.get("emoji")?, + file_type: row.get("file_type")?, + mime_type: row.get("mime_type")?, + file_size: row.get("file_size")?, + attachment_id: row.get("attachment_id")?, + attachment_references: row.get("attachment_references")?, + local_only: row.get::<_, i64>("local_only")? != 0, + sync_policy: row.get("sync_policy")?, + journal_date: row.get("journal_date")?, + property_definition_names: row.get("property_definition_names")?, + clock: row.get("clock")?, + synced_at: row.get("synced_at")?, + created_at: row.get("created_at")?, + modified_at: row.get("modified_at")?, + stored_at: row.get("stored_at")?, + }) + } +} diff --git a/apps/desktop-tauri/src-tauri/src/db/note_positions.rs b/apps/desktop-tauri/src-tauri/src/db/note_positions.rs new file mode 100644 index 000000000..91852f5f3 --- /dev/null +++ b/apps/desktop-tauri/src-tauri/src/db/note_positions.rs @@ -0,0 +1,19 @@ +use serde::{Deserialize, Serialize}; + +#[derive(Debug, Clone, Serialize, Deserialize, specta::Type)] +#[serde(rename_all = "camelCase")] +pub struct NotePosition { + pub path: String, + pub folder_path: String, + pub position: i64, +} + +impl NotePosition { + pub fn from_row(row: &rusqlite::Row<'_>) -> rusqlite::Result { + Ok(Self { + path: row.get("path")?, + folder_path: row.get("folder_path")?, + position: row.get("position")?, + }) + } +} diff --git a/apps/desktop-tauri/src-tauri/src/db/notes_cache.rs b/apps/desktop-tauri/src-tauri/src/db/notes_cache.rs new file mode 100644 index 000000000..257927d8b --- /dev/null +++ b/apps/desktop-tauri/src-tauri/src/db/notes_cache.rs @@ -0,0 +1,26 @@ +use serde::{Deserialize, Serialize}; + +#[derive(Debug, Clone, Serialize, Deserialize, specta::Type)] +#[serde(rename_all = "camelCase")] +pub struct PropertyDefinition { + pub name: String, + #[serde(rename = "type")] + pub r#type: String, + pub options: Option, + pub default_value: Option, + pub color: Option, + pub created_at: String, +} + +impl PropertyDefinition { + pub fn from_row(row: &rusqlite::Row<'_>) -> rusqlite::Result { + Ok(Self { + name: row.get("name")?, + r#type: row.get("type")?, + options: row.get("options")?, + default_value: row.get("default_value")?, + color: row.get("color")?, + created_at: row.get("created_at")?, + }) + } +} diff --git a/apps/desktop-tauri/src-tauri/tests/migrations_test.rs b/apps/desktop-tauri/src-tauri/tests/migrations_test.rs index f1ece2298..9a86a0316 100644 --- a/apps/desktop-tauri/src-tauri/tests/migrations_test.rs +++ b/apps/desktop-tauri/src-tauri/tests/migrations_test.rs @@ -246,3 +246,90 @@ fn projects_and_tasks_roundtrip() { assert!(task.clock.is_none()); assert!(task.field_clocks.is_none()); } + +#[test] +fn note_positions_roundtrip() { + let db = memry_desktop_tauri_lib::db::Db::open_memory().unwrap(); + let conn = db.conn().unwrap(); + + conn.execute( + "INSERT INTO note_positions (path, folder_path, position) VALUES (?1, ?2, ?3)", + rusqlite::params!["notes/foo.md", "notes", 3], + ) + .unwrap(); + + let pos = conn + .query_row( + "SELECT * FROM note_positions WHERE path = 'notes/foo.md'", + [], + memry_desktop_tauri_lib::db::note_positions::NotePosition::from_row, + ) + .unwrap(); + assert_eq!(pos.path, "notes/foo.md"); + assert_eq!(pos.folder_path, "notes"); + assert_eq!(pos.position, 3); +} + +#[test] +fn note_metadata_roundtrip() { + let db = memry_desktop_tauri_lib::db::Db::open_memory().unwrap(); + let conn = db.conn().unwrap(); + + conn.execute( + "INSERT INTO note_metadata \ + (id, path, title, file_type, local_only, sync_policy, created_at, modified_at) \ + VALUES (?1, ?2, ?3, ?4, ?5, ?6, ?7, ?8)", + rusqlite::params![ + "n1", + "notes/hello.md", + "Hello", + "markdown", + 1, + "sync", + "2026-04-25T00:00:00.000Z", + "2026-04-25T00:00:00.000Z", + ], + ) + .unwrap(); + + let meta = conn + .query_row( + "SELECT * FROM note_metadata WHERE id = 'n1'", + [], + memry_desktop_tauri_lib::db::note_metadata::NoteMetadata::from_row, + ) + .unwrap(); + assert_eq!(meta.path, "notes/hello.md"); + assert_eq!(meta.title, "Hello"); + assert_eq!(meta.file_type, "markdown"); + assert!(meta.local_only); + assert_eq!(meta.sync_policy, "sync"); + assert!(meta.emoji.is_none()); + assert!(meta.clock.is_none()); + assert!(!meta.stored_at.is_empty()); +} + +#[test] +fn property_definitions_roundtrip() { + let db = memry_desktop_tauri_lib::db::Db::open_memory().unwrap(); + let conn = db.conn().unwrap(); + + conn.execute( + "INSERT INTO property_definitions (name, type) VALUES (?1, ?2)", + rusqlite::params!["status", "select"], + ) + .unwrap(); + + let prop = conn + .query_row( + "SELECT * FROM property_definitions WHERE name = 'status'", + [], + memry_desktop_tauri_lib::db::notes_cache::PropertyDefinition::from_row, + ) + .unwrap(); + assert_eq!(prop.name, "status"); + assert_eq!(prop.r#type, "select"); + assert!(prop.options.is_none()); + assert!(prop.color.is_none()); + assert!(!prop.created_at.is_empty()); +} From 5e83a4f2cd73b1ed6abc4c3412d6b8743820e600 Mon Sep 17 00:00:00 2001 From: Kaan Karaca Date: Sat, 25 Apr 2026 03:34:30 +0300 Subject: [PATCH 13/25] m2(migrations): toggle FK off during replay; run integration tests by default MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit apply_pending now disables foreign_keys at connection scope before replaying pending migrations and re-enables (with foreign_key_check) after. SQLite silently no-ops the in-SQL PRAGMA foreign_keys=OFF inside a transaction, so Drizzle's CREATE __new_X / INSERT / DROP X / RENAME rebuild migrations (notably 0018) cascade-delete child rows on populated DBs when the caller opened the connection with FK enforcement on. New regression test rebuild_migrations_preserve_rows_when_fk_enforcement_is_on applies 0000-0017, inserts FK-related rows, then runs apply_pending — without the toggle the DROP TABLE projects step wipes statuses + tasks. Also pass --features test-helpers in the cargo:test script so the migrations_test target (which is required-features gated) actually runs in the default verification path. --- apps/desktop-tauri/package.json | 2 +- .../src-tauri/src/db/migrations.rs | 52 ++++++++++++- .../src-tauri/tests/migrations_test.rs | 73 +++++++++++++++++++ 3 files changed, 122 insertions(+), 5 deletions(-) diff --git a/apps/desktop-tauri/package.json b/apps/desktop-tauri/package.json index 790f74ad7..344a06530 100644 --- a/apps/desktop-tauri/package.json +++ b/apps/desktop-tauri/package.json @@ -17,7 +17,7 @@ "test:e2e": "playwright test", "cargo:check": "cd src-tauri && cargo check", "cargo:clippy": "cd src-tauri && cargo clippy -- -D warnings", - "cargo:test": "cd src-tauri && cargo test", + "cargo:test": "cd src-tauri && cargo test --features test-helpers", "cargo:fmt": "cd src-tauri && cargo fmt", "bindings:generate": "tsx scripts/generate-bindings.ts", "bindings:check": "tsx scripts/check-bindings.ts", diff --git a/apps/desktop-tauri/src-tauri/src/db/migrations.rs b/apps/desktop-tauri/src-tauri/src/db/migrations.rs index 707825558..9be5be536 100644 --- a/apps/desktop-tauri/src-tauri/src/db/migrations.rs +++ b/apps/desktop-tauri/src-tauri/src/db/migrations.rs @@ -138,12 +138,31 @@ pub fn apply_pending(conn: &mut Connection) -> AppResult<()> { bootstrap(conn)?; let applied = applied_migrations(conn)?; + let pending: Vec<(&'static str, &'static str)> = EMBEDDED + .iter() + .copied() + .filter(|(name, _)| !applied.contains(*name)) + .collect(); - for (name, sql) in EMBEDDED { - if applied.contains(*name) { - continue; - } + if pending.is_empty() { + return Ok(()); + } + // Several Drizzle ports (e.g. 0002, 0009, 0013, 0018) rebuild tables via + // the `CREATE __new_X / INSERT / DROP X / RENAME` pattern. SQLite silently + // no-ops `PRAGMA foreign_keys = OFF` inside a transaction, so the in-SQL + // pragma is not enough. If the caller opened the connection with FK + // enforcement on (Db::open / Db::open_memory both do), `DROP TABLE X` + // would cascade-delete rows in tables that reference X *before* the + // migration copies them, silently corrupting populated databases on + // upgrade. Toggle FK off at connection scope around the replay, then + // re-enable and verify integrity afterwards. + let prev_fk: i64 = conn.query_row("PRAGMA foreign_keys", [], |row| row.get(0))?; + if prev_fk != 0 { + conn.execute_batch("PRAGMA foreign_keys = OFF")?; + } + + for (name, sql) in &pending { let tx = conn.transaction()?; tx.execute_batch(sql) .map_err(|err| AppError::Database(format!("migration {name} failed: {err}")))?; @@ -154,6 +173,16 @@ pub fn apply_pending(conn: &mut Connection) -> AppResult<()> { tx.commit()?; } + if prev_fk != 0 { + conn.execute_batch("PRAGMA foreign_keys = ON")?; + let violations = collect_fk_violations(conn)?; + if !violations.is_empty() { + return Err(AppError::Database(format!( + "foreign_key_check failed after migration replay: {violations:?}" + ))); + } + } + Ok(()) } @@ -164,3 +193,18 @@ fn applied_migrations(conn: &Connection) -> AppResult> { Ok(applied) } + +fn collect_fk_violations(conn: &Connection) -> AppResult> { + let mut stmt = conn.prepare("PRAGMA foreign_key_check")?; + let rows = stmt.query_map([], |row| { + let table: String = row.get(0)?; + let rowid: Option = row.get(1)?; + let parent: String = row.get(2)?; + Ok(format!( + "{table}#{} -> {parent}", + rowid.map(|r| r.to_string()).unwrap_or_else(|| "?".into()) + )) + })?; + + Ok(rows.filter_map(Result::ok).collect()) +} diff --git a/apps/desktop-tauri/src-tauri/tests/migrations_test.rs b/apps/desktop-tauri/src-tauri/tests/migrations_test.rs index 9a86a0316..123369b9e 100644 --- a/apps/desktop-tauri/src-tauri/tests/migrations_test.rs +++ b/apps/desktop-tauri/src-tauri/tests/migrations_test.rs @@ -188,6 +188,79 @@ fn tasks_and_projects_have_field_clocks_column() { } } +#[test] +fn rebuild_migrations_preserve_rows_when_fk_enforcement_is_on() { + // Regression test for a bug where Db::open enabled FK enforcement before + // running apply_pending. Drizzle's big rebuild migration (0018) uses the + // CREATE __new_X / INSERT / DROP X / RENAME pattern; SQLite silently + // no-ops the in-SQL `PRAGMA foreign_keys = OFF` inside a transaction, so + // DROP TABLE cascades through ON DELETE CASCADE relationships and wipes + // child rows before the migration copies them. apply_pending must toggle + // FK off at connection scope around the replay. + // + // Simulates the upgrade path: a developer at schema version 0017 with + // populated rows, then apply_pending runs 0018-0028. + let mut conn = Connection::open_in_memory().unwrap(); + conn.execute_batch("PRAGMA foreign_keys = ON").unwrap(); + + migrations::bootstrap(&mut conn).unwrap(); + let upgrade_boundary = migrations::EMBEDDED + .iter() + .position(|(name, _)| name.starts_with("0018_")) + .expect("EMBEDDED must contain 0018_*"); + for (name, sql) in migrations::EMBEDDED.iter().take(upgrade_boundary) { + let tx = conn.transaction().unwrap(); + tx.execute_batch(sql).unwrap(); + tx.execute( + "INSERT INTO schema_migrations (name) VALUES (?1)", + rusqlite::params![name], + ) + .unwrap(); + tx.commit().unwrap(); + } + + conn.execute( + "INSERT INTO projects (id, name, color, position) VALUES ('p1', 'Inbox', '#000', 0)", + [], + ) + .unwrap(); + conn.execute( + "INSERT INTO statuses (id, project_id, name, color, position, is_default, is_done) \ + VALUES ('s1', 'p1', 'Todo', '#abc', 0, 1, 0)", + [], + ) + .unwrap(); + conn.execute( + "INSERT INTO tasks (id, project_id, status_id, title, priority, position) \ + VALUES ('t1', 'p1', 's1', 'first', 0, 0)", + [], + ) + .unwrap(); + + migrations::apply_pending(&mut conn).unwrap(); + + let project_count: i64 = conn + .query_row("SELECT COUNT(*) FROM projects", [], |row| row.get(0)) + .unwrap(); + let status_count: i64 = conn + .query_row("SELECT COUNT(*) FROM statuses", [], |row| row.get(0)) + .unwrap(); + let task_count: i64 = conn + .query_row("SELECT COUNT(*) FROM tasks", [], |row| row.get(0)) + .unwrap(); + + assert_eq!(project_count, 1, "projects row lost during rebuild replay"); + assert_eq!(status_count, 1, "statuses row lost during rebuild replay"); + assert_eq!(task_count, 1, "tasks row lost during rebuild replay"); + + // FK enforcement must be back on after apply_pending returns so the + // application sees referential integrity for subsequent writes. + let fk_state: i64 = conn + .query_row("PRAGMA foreign_keys", [], |row| row.get(0)) + .unwrap(); + assert_eq!(fk_state, 1, "apply_pending must restore FK enforcement"); +} + #[test] fn projects_and_tasks_roundtrip() { let db = memry_desktop_tauri_lib::db::Db::open_memory().unwrap(); From 3a42829a193cb2b6a00efd76901d132a484a7ed3 Mon Sep 17 00:00:00 2001 From: Kaan Karaca Date: Sat, 25 Apr 2026 03:41:47 +0300 Subject: [PATCH 14/25] m2(db): add calendar_{events,sources,external_events,bindings} structs MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Phase D batch 1: 4 calendar domain structs covering migrations 0024 (foundation) + 0025 (event target_calendar_id) + 0026 (event field_clocks) + 0027 (rich fields on events + external_events) + 0028 (source last_error). Field set is the post-migration union. Each module exposes the canonical struct name expected by the Phase F specta generator (CalendarEvent, CalendarSource, CalendarExternalEvent, CalendarBinding) with a from_row helper. No CRUD yet — those land per domain in later milestones. Smoke tests: 4 roundtrip tests in migrations_test.rs. The CalendarEvent test embeds Turkish UTF-8 (çğıöşü + uppercase variants) to guard against encoding bugs at the SQLite/rusqlite boundary. --- .../src-tauri/src/db/calendar_bindings.rs | 43 ++++++ .../src-tauri/src/db/calendar_events.rs | 61 ++++++++ .../src/db/calendar_external_events.rs | 63 ++++++++ .../src-tauri/src/db/calendar_sources.rs | 55 +++++++ apps/desktop-tauri/src-tauri/src/db/mod.rs | 4 + .../src-tauri/tests/migrations_test.rs | 138 ++++++++++++++++++ 6 files changed, 364 insertions(+) create mode 100644 apps/desktop-tauri/src-tauri/src/db/calendar_bindings.rs create mode 100644 apps/desktop-tauri/src-tauri/src/db/calendar_events.rs create mode 100644 apps/desktop-tauri/src-tauri/src/db/calendar_external_events.rs create mode 100644 apps/desktop-tauri/src-tauri/src/db/calendar_sources.rs diff --git a/apps/desktop-tauri/src-tauri/src/db/calendar_bindings.rs b/apps/desktop-tauri/src-tauri/src/db/calendar_bindings.rs new file mode 100644 index 000000000..bdedac9dd --- /dev/null +++ b/apps/desktop-tauri/src-tauri/src/db/calendar_bindings.rs @@ -0,0 +1,43 @@ +use serde::{Deserialize, Serialize}; + +#[derive(Debug, Clone, Serialize, Deserialize, specta::Type)] +#[serde(rename_all = "camelCase")] +pub struct CalendarBinding { + pub id: String, + pub source_type: String, + pub source_id: String, + pub provider: String, + pub remote_calendar_id: String, + pub remote_event_id: String, + pub ownership_mode: String, + pub writeback_mode: String, + pub remote_version: Option, + pub last_local_snapshot: Option, + pub archived_at: Option, + pub clock: Option, + pub synced_at: Option, + pub created_at: String, + pub modified_at: String, +} + +impl CalendarBinding { + pub fn from_row(row: &rusqlite::Row<'_>) -> rusqlite::Result { + Ok(Self { + id: row.get("id")?, + source_type: row.get("source_type")?, + source_id: row.get("source_id")?, + provider: row.get("provider")?, + remote_calendar_id: row.get("remote_calendar_id")?, + remote_event_id: row.get("remote_event_id")?, + ownership_mode: row.get("ownership_mode")?, + writeback_mode: row.get("writeback_mode")?, + remote_version: row.get("remote_version")?, + last_local_snapshot: row.get("last_local_snapshot")?, + archived_at: row.get("archived_at")?, + clock: row.get("clock")?, + synced_at: row.get("synced_at")?, + created_at: row.get("created_at")?, + modified_at: row.get("modified_at")?, + }) + } +} diff --git a/apps/desktop-tauri/src-tauri/src/db/calendar_events.rs b/apps/desktop-tauri/src-tauri/src/db/calendar_events.rs new file mode 100644 index 000000000..12bfb9ba5 --- /dev/null +++ b/apps/desktop-tauri/src-tauri/src/db/calendar_events.rs @@ -0,0 +1,61 @@ +use serde::{Deserialize, Serialize}; + +#[derive(Debug, Clone, Serialize, Deserialize, specta::Type)] +#[serde(rename_all = "camelCase")] +pub struct CalendarEvent { + pub id: String, + pub title: String, + pub description: Option, + pub location: Option, + pub start_at: String, + pub end_at: Option, + pub timezone: String, + pub is_all_day: bool, + pub recurrence_rule: Option, + pub recurrence_exceptions: Option, + pub archived_at: Option, + pub clock: Option, + pub synced_at: Option, + pub created_at: String, + pub modified_at: String, + pub target_calendar_id: Option, + pub field_clocks: Option, + pub attendees: Option, + pub reminders: Option, + pub visibility: Option, + pub color_id: Option, + pub conference_data: Option, + pub parent_event_id: Option, + pub original_start_time: Option, +} + +impl CalendarEvent { + pub fn from_row(row: &rusqlite::Row<'_>) -> rusqlite::Result { + Ok(Self { + id: row.get("id")?, + title: row.get("title")?, + description: row.get("description")?, + location: row.get("location")?, + start_at: row.get("start_at")?, + end_at: row.get("end_at")?, + timezone: row.get("timezone")?, + is_all_day: row.get::<_, i64>("is_all_day")? != 0, + recurrence_rule: row.get("recurrence_rule")?, + recurrence_exceptions: row.get("recurrence_exceptions")?, + archived_at: row.get("archived_at")?, + clock: row.get("clock")?, + synced_at: row.get("synced_at")?, + created_at: row.get("created_at")?, + modified_at: row.get("modified_at")?, + target_calendar_id: row.get("target_calendar_id")?, + field_clocks: row.get("field_clocks")?, + attendees: row.get("attendees")?, + reminders: row.get("reminders")?, + visibility: row.get("visibility")?, + color_id: row.get("color_id")?, + conference_data: row.get("conference_data")?, + parent_event_id: row.get("parent_event_id")?, + original_start_time: row.get("original_start_time")?, + }) + } +} diff --git a/apps/desktop-tauri/src-tauri/src/db/calendar_external_events.rs b/apps/desktop-tauri/src-tauri/src/db/calendar_external_events.rs new file mode 100644 index 000000000..cd8af4504 --- /dev/null +++ b/apps/desktop-tauri/src-tauri/src/db/calendar_external_events.rs @@ -0,0 +1,63 @@ +use serde::{Deserialize, Serialize}; + +#[derive(Debug, Clone, Serialize, Deserialize, specta::Type)] +#[serde(rename_all = "camelCase")] +pub struct CalendarExternalEvent { + pub id: String, + pub source_id: String, + pub remote_event_id: String, + pub remote_etag: Option, + pub remote_updated_at: Option, + pub title: String, + pub description: Option, + pub location: Option, + pub start_at: String, + pub end_at: Option, + pub timezone: Option, + pub is_all_day: bool, + pub status: String, + pub recurrence_rule: Option, + pub raw_payload: Option, + pub archived_at: Option, + pub clock: Option, + pub synced_at: Option, + pub created_at: String, + pub modified_at: String, + pub attendees: Option, + pub reminders: Option, + pub visibility: Option, + pub color_id: Option, + pub conference_data: Option, +} + +impl CalendarExternalEvent { + pub fn from_row(row: &rusqlite::Row<'_>) -> rusqlite::Result { + Ok(Self { + id: row.get("id")?, + source_id: row.get("source_id")?, + remote_event_id: row.get("remote_event_id")?, + remote_etag: row.get("remote_etag")?, + remote_updated_at: row.get("remote_updated_at")?, + title: row.get("title")?, + description: row.get("description")?, + location: row.get("location")?, + start_at: row.get("start_at")?, + end_at: row.get("end_at")?, + timezone: row.get("timezone")?, + is_all_day: row.get::<_, i64>("is_all_day")? != 0, + status: row.get("status")?, + recurrence_rule: row.get("recurrence_rule")?, + raw_payload: row.get("raw_payload")?, + archived_at: row.get("archived_at")?, + clock: row.get("clock")?, + synced_at: row.get("synced_at")?, + created_at: row.get("created_at")?, + modified_at: row.get("modified_at")?, + attendees: row.get("attendees")?, + reminders: row.get("reminders")?, + visibility: row.get("visibility")?, + color_id: row.get("color_id")?, + conference_data: row.get("conference_data")?, + }) + } +} diff --git a/apps/desktop-tauri/src-tauri/src/db/calendar_sources.rs b/apps/desktop-tauri/src-tauri/src/db/calendar_sources.rs new file mode 100644 index 000000000..b1f2963cf --- /dev/null +++ b/apps/desktop-tauri/src-tauri/src/db/calendar_sources.rs @@ -0,0 +1,55 @@ +use serde::{Deserialize, Serialize}; + +#[derive(Debug, Clone, Serialize, Deserialize, specta::Type)] +#[serde(rename_all = "camelCase")] +pub struct CalendarSource { + pub id: String, + pub provider: String, + pub kind: String, + pub account_id: Option, + pub remote_id: String, + pub title: String, + pub timezone: Option, + pub color: Option, + pub is_primary: bool, + pub is_selected: bool, + pub is_memry_managed: bool, + pub sync_cursor: Option, + pub sync_status: String, + pub last_synced_at: Option, + pub metadata: Option, + pub archived_at: Option, + pub clock: Option, + pub synced_at: Option, + pub created_at: String, + pub modified_at: String, + pub last_error: Option, +} + +impl CalendarSource { + pub fn from_row(row: &rusqlite::Row<'_>) -> rusqlite::Result { + Ok(Self { + id: row.get("id")?, + provider: row.get("provider")?, + kind: row.get("kind")?, + account_id: row.get("account_id")?, + remote_id: row.get("remote_id")?, + title: row.get("title")?, + timezone: row.get("timezone")?, + color: row.get("color")?, + is_primary: row.get::<_, i64>("is_primary")? != 0, + is_selected: row.get::<_, i64>("is_selected")? != 0, + is_memry_managed: row.get::<_, i64>("is_memry_managed")? != 0, + sync_cursor: row.get("sync_cursor")?, + sync_status: row.get("sync_status")?, + last_synced_at: row.get("last_synced_at")?, + metadata: row.get("metadata")?, + archived_at: row.get("archived_at")?, + clock: row.get("clock")?, + synced_at: row.get("synced_at")?, + created_at: row.get("created_at")?, + modified_at: row.get("modified_at")?, + last_error: row.get("last_error")?, + }) + } +} diff --git a/apps/desktop-tauri/src-tauri/src/db/mod.rs b/apps/desktop-tauri/src-tauri/src/db/mod.rs index 040327e90..7015083d1 100644 --- a/apps/desktop-tauri/src-tauri/src/db/mod.rs +++ b/apps/desktop-tauri/src-tauri/src/db/mod.rs @@ -9,6 +9,10 @@ use std::{ pub mod migrations; +pub mod calendar_bindings; +pub mod calendar_events; +pub mod calendar_external_events; +pub mod calendar_sources; pub mod note_metadata; pub mod note_positions; pub mod notes_cache; diff --git a/apps/desktop-tauri/src-tauri/tests/migrations_test.rs b/apps/desktop-tauri/src-tauri/tests/migrations_test.rs index 123369b9e..14752dac0 100644 --- a/apps/desktop-tauri/src-tauri/tests/migrations_test.rs +++ b/apps/desktop-tauri/src-tauri/tests/migrations_test.rs @@ -406,3 +406,141 @@ fn property_definitions_roundtrip() { assert!(prop.color.is_none()); assert!(!prop.created_at.is_empty()); } + +#[test] +fn calendar_event_roundtrip() { + // Turkish-character roundtrip is embedded here (Phase D gotcha #3). + // If SQLite or rusqlite mangles UTF-8, the title compare will fail. + let db = memry_desktop_tauri_lib::db::Db::open_memory().unwrap(); + let conn = db.conn().unwrap(); + + let title = "Toplantı: çay & kahve — ÖĞRENME günü"; + conn.execute( + "INSERT INTO calendar_events (id, title, start_at) VALUES (?1, ?2, ?3)", + rusqlite::params!["e1", title, "2026-04-25T10:00:00.000Z"], + ) + .unwrap(); + + let ev = conn + .query_row( + "SELECT * FROM calendar_events WHERE id = 'e1'", + [], + memry_desktop_tauri_lib::db::calendar_events::CalendarEvent::from_row, + ) + .unwrap(); + assert_eq!(ev.id, "e1"); + assert_eq!(ev.title, title, "Turkish UTF-8 must roundtrip byte-identical"); + assert_eq!(ev.start_at, "2026-04-25T10:00:00.000Z"); + assert_eq!(ev.timezone, "UTC"); + assert!(!ev.is_all_day); + assert!(ev.field_clocks.is_none()); + assert!(ev.target_calendar_id.is_none()); + assert!(ev.attendees.is_none()); +} + +#[test] +fn calendar_source_roundtrip() { + let db = memry_desktop_tauri_lib::db::Db::open_memory().unwrap(); + let conn = db.conn().unwrap(); + + conn.execute( + "INSERT INTO calendar_sources (id, provider, kind, remote_id, title) \ + VALUES (?1, ?2, ?3, ?4, ?5)", + rusqlite::params!["src1", "google", "calendar", "primary@example.com", "Primary"], + ) + .unwrap(); + + let src = conn + .query_row( + "SELECT * FROM calendar_sources WHERE id = 'src1'", + [], + memry_desktop_tauri_lib::db::calendar_sources::CalendarSource::from_row, + ) + .unwrap(); + assert_eq!(src.id, "src1"); + assert_eq!(src.provider, "google"); + assert_eq!(src.kind, "calendar"); + assert_eq!(src.remote_id, "primary@example.com"); + assert_eq!(src.title, "Primary"); + assert!(!src.is_primary); + assert!(!src.is_selected); + assert!(!src.is_memry_managed); + assert_eq!(src.sync_status, "idle"); + assert!(src.last_error.is_none()); +} + +#[test] +fn calendar_external_event_roundtrip() { + let db = memry_desktop_tauri_lib::db::Db::open_memory().unwrap(); + let conn = db.conn().unwrap(); + + conn.execute( + "INSERT INTO calendar_sources (id, provider, kind, remote_id, title) \ + VALUES (?1, ?2, ?3, ?4, ?5)", + rusqlite::params!["src1", "google", "calendar", "primary@example.com", "Primary"], + ) + .unwrap(); + conn.execute( + "INSERT INTO calendar_external_events \ + (id, source_id, remote_event_id, title, start_at) \ + VALUES (?1, ?2, ?3, ?4, ?5)", + rusqlite::params!["xev1", "src1", "remote-abc", "Standup", "2026-04-25T09:00:00.000Z"], + ) + .unwrap(); + + let xev = conn + .query_row( + "SELECT * FROM calendar_external_events WHERE id = 'xev1'", + [], + memry_desktop_tauri_lib::db::calendar_external_events::CalendarExternalEvent::from_row, + ) + .unwrap(); + assert_eq!(xev.id, "xev1"); + assert_eq!(xev.source_id, "src1"); + assert_eq!(xev.remote_event_id, "remote-abc"); + assert_eq!(xev.title, "Standup"); + assert_eq!(xev.status, "confirmed"); + assert!(!xev.is_all_day); + assert!(xev.attendees.is_none()); +} + +#[test] +fn calendar_binding_roundtrip() { + let db = memry_desktop_tauri_lib::db::Db::open_memory().unwrap(); + let conn = db.conn().unwrap(); + + conn.execute( + "INSERT INTO calendar_bindings \ + (id, source_type, source_id, provider, remote_calendar_id, remote_event_id, \ + ownership_mode, writeback_mode) \ + VALUES (?1, ?2, ?3, ?4, ?5, ?6, ?7, ?8)", + rusqlite::params![ + "b1", + "task", + "t1", + "google", + "primary@example.com", + "remote-event-1", + "memry-owned", + "two-way", + ], + ) + .unwrap(); + + let b = conn + .query_row( + "SELECT * FROM calendar_bindings WHERE id = 'b1'", + [], + memry_desktop_tauri_lib::db::calendar_bindings::CalendarBinding::from_row, + ) + .unwrap(); + assert_eq!(b.id, "b1"); + assert_eq!(b.source_type, "task"); + assert_eq!(b.source_id, "t1"); + assert_eq!(b.provider, "google"); + assert_eq!(b.remote_calendar_id, "primary@example.com"); + assert_eq!(b.remote_event_id, "remote-event-1"); + assert_eq!(b.ownership_mode, "memry-owned"); + assert_eq!(b.writeback_mode, "two-way"); + assert!(b.remote_version.is_none()); +} From 8fb44f448d7d965c553bddd5125e346883ef3222 Mon Sep 17 00:00:00 2001 From: Kaan Karaca Date: Sat, 25 Apr 2026 03:45:54 +0300 Subject: [PATCH 15/25] m2(db): add inbox/bookmarks/reminders/tag_definitions/folder_configs structs MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Phase D batch 2: 5 user-collection structs covering migrations 0000 (inbox_items base) + 0001 (bookmarks) + 0002 (inbox rebuild + filing_history/inbox_item_tags/inbox_stats) + 0004 (reminders) + 0005 (inbox viewed_at, inbox_stats reminder count) + 0007 (tag_definitions) + 0011 (inbox sync metadata + local_only) + 0016 (tag_definitions clock) + 0018 (rebuild reset) + 0019 (inbox capture_source) + 0023 (folder_configs). Each module exposes the canonical struct name expected by the Phase F specta generator (InboxItem, Bookmark, Reminder, TagDefinition, FolderConfig) with a from_row helper. inbox_jobs is intentionally deferred — that struct lands with the M8.7 snooze scheduler. Notable column quirks: - InboxItem.local_only is Option: the column was added by ALTER TABLE in 0011 with no NOT NULL, so backfilled rows were nullable. The 0018 rebuild kept the same nullable shape with default 0. Strict type follows the schema (Phase D gotcha #1). - InboxItem.r#type uses the raw identifier escape; serde renames it back to `type` via #[serde(rename = ...)]. - TagDefinition uses `name` as primary key (no `id` column) and has no synced_at column even after the 0018 rebuild — only clock was added in 0016. Smoke tests: 5 roundtrip tests in migrations_test.rs, all asserting row.get path matches column names. Total tests: 11 (Phase B/C) + 4 (calendar) + 5 (collections) = 20 passing. --- .../src-tauri/src/db/bookmarks.rs | 23 +++ .../src-tauri/src/db/folder_configs.rs | 23 +++ apps/desktop-tauri/src-tauri/src/db/inbox.rs | 66 +++++++++ apps/desktop-tauri/src-tauri/src/db/mod.rs | 5 + .../src-tauri/src/db/reminders.rs | 43 ++++++ .../src-tauri/src/db/tag_definitions.rs | 21 +++ .../src-tauri/tests/migrations_test.rs | 136 ++++++++++++++++++ 7 files changed, 317 insertions(+) create mode 100644 apps/desktop-tauri/src-tauri/src/db/bookmarks.rs create mode 100644 apps/desktop-tauri/src-tauri/src/db/folder_configs.rs create mode 100644 apps/desktop-tauri/src-tauri/src/db/inbox.rs create mode 100644 apps/desktop-tauri/src-tauri/src/db/reminders.rs create mode 100644 apps/desktop-tauri/src-tauri/src/db/tag_definitions.rs diff --git a/apps/desktop-tauri/src-tauri/src/db/bookmarks.rs b/apps/desktop-tauri/src-tauri/src/db/bookmarks.rs new file mode 100644 index 000000000..6e813d151 --- /dev/null +++ b/apps/desktop-tauri/src-tauri/src/db/bookmarks.rs @@ -0,0 +1,23 @@ +use serde::{Deserialize, Serialize}; + +#[derive(Debug, Clone, Serialize, Deserialize, specta::Type)] +#[serde(rename_all = "camelCase")] +pub struct Bookmark { + pub id: String, + pub item_type: String, + pub item_id: String, + pub position: i64, + pub created_at: String, +} + +impl Bookmark { + pub fn from_row(row: &rusqlite::Row<'_>) -> rusqlite::Result { + Ok(Self { + id: row.get("id")?, + item_type: row.get("item_type")?, + item_id: row.get("item_id")?, + position: row.get("position")?, + created_at: row.get("created_at")?, + }) + } +} diff --git a/apps/desktop-tauri/src-tauri/src/db/folder_configs.rs b/apps/desktop-tauri/src-tauri/src/db/folder_configs.rs new file mode 100644 index 000000000..c673bd85c --- /dev/null +++ b/apps/desktop-tauri/src-tauri/src/db/folder_configs.rs @@ -0,0 +1,23 @@ +use serde::{Deserialize, Serialize}; + +#[derive(Debug, Clone, Serialize, Deserialize, specta::Type)] +#[serde(rename_all = "camelCase")] +pub struct FolderConfig { + pub path: String, + pub icon: Option, + pub clock: Option, + pub created_at: String, + pub modified_at: String, +} + +impl FolderConfig { + pub fn from_row(row: &rusqlite::Row<'_>) -> rusqlite::Result { + Ok(Self { + path: row.get("path")?, + icon: row.get("icon")?, + clock: row.get("clock")?, + created_at: row.get("created_at")?, + modified_at: row.get("modified_at")?, + }) + } +} diff --git a/apps/desktop-tauri/src-tauri/src/db/inbox.rs b/apps/desktop-tauri/src-tauri/src/db/inbox.rs new file mode 100644 index 000000000..6b764ebb4 --- /dev/null +++ b/apps/desktop-tauri/src-tauri/src/db/inbox.rs @@ -0,0 +1,66 @@ +use serde::{Deserialize, Serialize}; + +#[derive(Debug, Clone, Serialize, Deserialize, specta::Type)] +#[serde(rename_all = "camelCase")] +pub struct InboxItem { + pub id: String, + #[serde(rename = "type")] + pub r#type: String, + pub title: String, + pub content: Option, + pub created_at: String, + pub modified_at: String, + pub filed_at: Option, + pub filed_to: Option, + pub filed_action: Option, + pub snoozed_until: Option, + pub snooze_reason: Option, + pub viewed_at: Option, + pub processing_status: Option, + pub processing_error: Option, + pub metadata: Option, + pub attachment_path: Option, + pub thumbnail_path: Option, + pub transcription: Option, + pub transcription_status: Option, + pub source_url: Option, + pub source_title: Option, + pub archived_at: Option, + pub clock: Option, + pub synced_at: Option, + pub local_only: Option, + pub capture_source: Option, +} + +impl InboxItem { + pub fn from_row(row: &rusqlite::Row<'_>) -> rusqlite::Result { + Ok(Self { + id: row.get("id")?, + r#type: row.get("type")?, + title: row.get("title")?, + content: row.get("content")?, + created_at: row.get("created_at")?, + modified_at: row.get("modified_at")?, + filed_at: row.get("filed_at")?, + filed_to: row.get("filed_to")?, + filed_action: row.get("filed_action")?, + snoozed_until: row.get("snoozed_until")?, + snooze_reason: row.get("snooze_reason")?, + viewed_at: row.get("viewed_at")?, + processing_status: row.get("processing_status")?, + processing_error: row.get("processing_error")?, + metadata: row.get("metadata")?, + attachment_path: row.get("attachment_path")?, + thumbnail_path: row.get("thumbnail_path")?, + transcription: row.get("transcription")?, + transcription_status: row.get("transcription_status")?, + source_url: row.get("source_url")?, + source_title: row.get("source_title")?, + archived_at: row.get("archived_at")?, + clock: row.get("clock")?, + synced_at: row.get("synced_at")?, + local_only: row.get::<_, Option>("local_only")?.map(|v| v != 0), + capture_source: row.get("capture_source")?, + }) + } +} diff --git a/apps/desktop-tauri/src-tauri/src/db/mod.rs b/apps/desktop-tauri/src-tauri/src/db/mod.rs index 7015083d1..47bd48df7 100644 --- a/apps/desktop-tauri/src-tauri/src/db/mod.rs +++ b/apps/desktop-tauri/src-tauri/src/db/mod.rs @@ -9,15 +9,20 @@ use std::{ pub mod migrations; +pub mod bookmarks; pub mod calendar_bindings; pub mod calendar_events; pub mod calendar_external_events; pub mod calendar_sources; +pub mod folder_configs; +pub mod inbox; pub mod note_metadata; pub mod note_positions; pub mod notes_cache; pub mod projects; +pub mod reminders; pub mod statuses; +pub mod tag_definitions; pub mod tasks; pub type DbGuard<'a> = MutexGuard<'a, Connection>; diff --git a/apps/desktop-tauri/src-tauri/src/db/reminders.rs b/apps/desktop-tauri/src-tauri/src/db/reminders.rs new file mode 100644 index 000000000..474568a8d --- /dev/null +++ b/apps/desktop-tauri/src-tauri/src/db/reminders.rs @@ -0,0 +1,43 @@ +use serde::{Deserialize, Serialize}; + +#[derive(Debug, Clone, Serialize, Deserialize, specta::Type)] +#[serde(rename_all = "camelCase")] +pub struct Reminder { + pub id: String, + pub target_type: String, + pub target_id: String, + pub remind_at: String, + pub highlight_text: Option, + pub highlight_start: Option, + pub highlight_end: Option, + pub title: Option, + pub note: Option, + pub status: String, + pub triggered_at: Option, + pub dismissed_at: Option, + pub snoozed_until: Option, + pub created_at: String, + pub modified_at: String, +} + +impl Reminder { + pub fn from_row(row: &rusqlite::Row<'_>) -> rusqlite::Result { + Ok(Self { + id: row.get("id")?, + target_type: row.get("target_type")?, + target_id: row.get("target_id")?, + remind_at: row.get("remind_at")?, + highlight_text: row.get("highlight_text")?, + highlight_start: row.get("highlight_start")?, + highlight_end: row.get("highlight_end")?, + title: row.get("title")?, + note: row.get("note")?, + status: row.get("status")?, + triggered_at: row.get("triggered_at")?, + dismissed_at: row.get("dismissed_at")?, + snoozed_until: row.get("snoozed_until")?, + created_at: row.get("created_at")?, + modified_at: row.get("modified_at")?, + }) + } +} diff --git a/apps/desktop-tauri/src-tauri/src/db/tag_definitions.rs b/apps/desktop-tauri/src-tauri/src/db/tag_definitions.rs new file mode 100644 index 000000000..9c9181645 --- /dev/null +++ b/apps/desktop-tauri/src-tauri/src/db/tag_definitions.rs @@ -0,0 +1,21 @@ +use serde::{Deserialize, Serialize}; + +#[derive(Debug, Clone, Serialize, Deserialize, specta::Type)] +#[serde(rename_all = "camelCase")] +pub struct TagDefinition { + pub name: String, + pub color: String, + pub clock: Option, + pub created_at: String, +} + +impl TagDefinition { + pub fn from_row(row: &rusqlite::Row<'_>) -> rusqlite::Result { + Ok(Self { + name: row.get("name")?, + color: row.get("color")?, + clock: row.get("clock")?, + created_at: row.get("created_at")?, + }) + } +} diff --git a/apps/desktop-tauri/src-tauri/tests/migrations_test.rs b/apps/desktop-tauri/src-tauri/tests/migrations_test.rs index 14752dac0..85c27b9b5 100644 --- a/apps/desktop-tauri/src-tauri/tests/migrations_test.rs +++ b/apps/desktop-tauri/src-tauri/tests/migrations_test.rs @@ -504,6 +504,142 @@ fn calendar_external_event_roundtrip() { assert!(xev.attendees.is_none()); } +#[test] +fn inbox_item_roundtrip() { + let db = memry_desktop_tauri_lib::db::Db::open_memory().unwrap(); + let conn = db.conn().unwrap(); + + conn.execute( + "INSERT INTO inbox_items (id, type, title) VALUES (?1, ?2, ?3)", + rusqlite::params!["i1", "note", "Captured thought"], + ) + .unwrap(); + + let item = conn + .query_row( + "SELECT * FROM inbox_items WHERE id = 'i1'", + [], + memry_desktop_tauri_lib::db::inbox::InboxItem::from_row, + ) + .unwrap(); + assert_eq!(item.id, "i1"); + assert_eq!(item.r#type, "note"); + assert_eq!(item.title, "Captured thought"); + assert!(item.content.is_none()); + assert!(item.archived_at.is_none()); + assert!(item.clock.is_none()); + assert!(item.synced_at.is_none()); + assert!(item.capture_source.is_none()); + // local_only: ALTER ADD COLUMN INTEGER DEFAULT 0; on a fresh insert the + // default applies → Some(false). The Option mapping captures the + // Phase D gotcha that the column is nullable for backfilled rows. + assert_eq!(item.local_only, Some(false)); + assert_eq!(item.processing_status.as_deref(), Some("complete")); +} + +#[test] +fn bookmark_roundtrip() { + let db = memry_desktop_tauri_lib::db::Db::open_memory().unwrap(); + let conn = db.conn().unwrap(); + + conn.execute( + "INSERT INTO bookmarks (id, item_type, item_id, position) VALUES (?1, ?2, ?3, ?4)", + rusqlite::params!["bm1", "note", "n42", 5], + ) + .unwrap(); + + let bm = conn + .query_row( + "SELECT * FROM bookmarks WHERE id = 'bm1'", + [], + memry_desktop_tauri_lib::db::bookmarks::Bookmark::from_row, + ) + .unwrap(); + assert_eq!(bm.id, "bm1"); + assert_eq!(bm.item_type, "note"); + assert_eq!(bm.item_id, "n42"); + assert_eq!(bm.position, 5); + assert!(!bm.created_at.is_empty()); +} + +#[test] +fn reminder_roundtrip() { + let db = memry_desktop_tauri_lib::db::Db::open_memory().unwrap(); + let conn = db.conn().unwrap(); + + conn.execute( + "INSERT INTO reminders (id, target_type, target_id, remind_at) \ + VALUES (?1, ?2, ?3, ?4)", + rusqlite::params!["rem1", "note", "n42", "2026-04-25T15:00:00.000Z"], + ) + .unwrap(); + + let rem = conn + .query_row( + "SELECT * FROM reminders WHERE id = 'rem1'", + [], + memry_desktop_tauri_lib::db::reminders::Reminder::from_row, + ) + .unwrap(); + assert_eq!(rem.id, "rem1"); + assert_eq!(rem.target_type, "note"); + assert_eq!(rem.target_id, "n42"); + assert_eq!(rem.remind_at, "2026-04-25T15:00:00.000Z"); + assert_eq!(rem.status, "pending"); + assert!(rem.title.is_none()); + assert!(rem.highlight_text.is_none()); + assert!(rem.triggered_at.is_none()); +} + +#[test] +fn tag_definition_roundtrip() { + let db = memry_desktop_tauri_lib::db::Db::open_memory().unwrap(); + let conn = db.conn().unwrap(); + + conn.execute( + "INSERT INTO tag_definitions (name, color) VALUES (?1, ?2)", + rusqlite::params!["work", "#3b82f6"], + ) + .unwrap(); + + let tag = conn + .query_row( + "SELECT * FROM tag_definitions WHERE name = 'work'", + [], + memry_desktop_tauri_lib::db::tag_definitions::TagDefinition::from_row, + ) + .unwrap(); + assert_eq!(tag.name, "work"); + assert_eq!(tag.color, "#3b82f6"); + assert!(tag.clock.is_none()); + assert!(!tag.created_at.is_empty()); +} + +#[test] +fn folder_config_roundtrip() { + let db = memry_desktop_tauri_lib::db::Db::open_memory().unwrap(); + let conn = db.conn().unwrap(); + + conn.execute( + "INSERT INTO folder_configs (path, icon) VALUES (?1, ?2)", + rusqlite::params!["notes/projects", "📂"], + ) + .unwrap(); + + let cfg = conn + .query_row( + "SELECT * FROM folder_configs WHERE path = 'notes/projects'", + [], + memry_desktop_tauri_lib::db::folder_configs::FolderConfig::from_row, + ) + .unwrap(); + assert_eq!(cfg.path, "notes/projects"); + assert_eq!(cfg.icon.as_deref(), Some("📂")); + assert!(cfg.clock.is_none()); + assert!(!cfg.created_at.is_empty()); + assert!(!cfg.modified_at.is_empty()); +} + #[test] fn calendar_binding_roundtrip() { let db = memry_desktop_tauri_lib::db::Db::open_memory().unwrap(); From 4dd8d98e67d09e5b592e74bced853bc79aca7390 Mon Sep 17 00:00:00 2001 From: Kaan Karaca Date: Sun, 26 Apr 2026 00:23:28 +0300 Subject: [PATCH 16/25] m2(migrations): fix concurrent-replay race + FK pragma restore on error MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Two correctness bugs flagged by Codex review of the M2 migration runner: 1. Concurrent apply_pending could crash the second runner. Two app processes (dev hot-reload, double-launch) both bootstrapped, both read the same applied set, both computed the same pending list, both opened a BEGIN DEFERRED tx. Whichever lost the write-lock race crashed on either non-IF-NOT-EXISTS DDL (0001 `CREATE TABLE bookmarks`) or on the schema_migrations.name PRIMARY KEY. Fix: each per-migration tx now uses BEGIN IMMEDIATE so runners serialize on the SQLite write lock, and re-checks schema_migrations under that lock — if a sibling already recorded this migration, commit the empty tx and continue. The replay is now convergent. 2. apply_pending toggles PRAGMA foreign_keys = OFF for the rebuild migrations (0002/0009/0013/0018 use the CREATE __new_X / INSERT / DROP X / RENAME pattern that needs FK off at connection scope). If a migration failed mid-replay, the early ? return skipped the restore block, leaving FK enforcement permanently off on a connection that Db wraps in Arc> and reuses for every subsequent app write. Fix: scope the restore to run on both success and failure paths via an early-binding result, and make it best-effort so a restore failure doesn't mask the original migration error. TDD: two regression tests added before the fix. - apply_pending_restores_fk_state_on_migration_failure: pre-creates a colliding bookmarks table so 0001 fails, asserts FK is back to ON. RED: "PRAGMA foreign_keys must be restored to ON". GREEN with fix. - apply_pending_is_safe_under_concurrent_runners: temp file DB, WAL set on a setup connection, two threads with a Barrier race apply_pending, asserts both succeed and schema_migrations has exactly one row per embedded migration. RED: "UNIQUE constraint failed: schema_migrations.name". GREEN with fix and stable across 5 consecutive runs. --- .../src-tauri/src/db/migrations.rs | 73 ++++++++--- .../src-tauri/tests/migrations_test.rs | 120 ++++++++++++++++++ 2 files changed, 175 insertions(+), 18 deletions(-) diff --git a/apps/desktop-tauri/src-tauri/src/db/migrations.rs b/apps/desktop-tauri/src-tauri/src/db/migrations.rs index 9be5be536..6a4e53356 100644 --- a/apps/desktop-tauri/src-tauri/src/db/migrations.rs +++ b/apps/desktop-tauri/src-tauri/src/db/migrations.rs @@ -137,14 +137,15 @@ pub fn bootstrap(conn: &mut Connection) -> AppResult<()> { pub fn apply_pending(conn: &mut Connection) -> AppResult<()> { bootstrap(conn)?; - let applied = applied_migrations(conn)?; - let pending: Vec<(&'static str, &'static str)> = EMBEDDED - .iter() - .copied() - .filter(|(name, _)| !applied.contains(*name)) - .collect(); - - if pending.is_empty() { + // Cheap upfront check: if every embedded migration is already recorded + // we skip the FK toggle entirely. The authoritative check happens again + // inside each per-migration IMMEDIATE transaction below — that is what + // makes concurrent runners safe; this is just an optimization. + let any_pending = { + let applied = applied_migrations(conn)?; + EMBEDDED.iter().any(|(name, _)| !applied.contains(*name)) + }; + if !any_pending { return Ok(()); } @@ -162,19 +163,20 @@ pub fn apply_pending(conn: &mut Connection) -> AppResult<()> { conn.execute_batch("PRAGMA foreign_keys = OFF")?; } - for (name, sql) in &pending { - let tx = conn.transaction()?; - tx.execute_batch(sql) - .map_err(|err| AppError::Database(format!("migration {name} failed: {err}")))?; - tx.execute( - "INSERT INTO schema_migrations (name) VALUES (?1)", - params![name], - )?; - tx.commit()?; + let result = replay_migrations(conn); + + // Restore FK enforcement on BOTH success and failure paths. If we don't, + // a mid-replay failure leaves the connection (which Db wraps in + // Arc> and reuses across the app) with FK checks + // permanently off. Best-effort: if the restore PRAGMA itself errors, we + // still propagate the original migration error. + if prev_fk != 0 { + let _ = conn.execute_batch("PRAGMA foreign_keys = ON"); } + result?; + if prev_fk != 0 { - conn.execute_batch("PRAGMA foreign_keys = ON")?; let violations = collect_fk_violations(conn)?; if !violations.is_empty() { return Err(AppError::Database(format!( @@ -186,6 +188,41 @@ pub fn apply_pending(conn: &mut Connection) -> AppResult<()> { Ok(()) } +/// Replay every embedded migration that has not yet been recorded. +/// +/// Each migration runs in its own `BEGIN IMMEDIATE` transaction so that +/// concurrent runners (two app processes against the same data DB) serialize +/// on the SQLite write lock instead of racing each other. Inside the tx we +/// re-check `schema_migrations` under that lock — if a sibling runner already +/// recorded this migration, we commit the empty tx and continue. This makes +/// the replay convergent: whichever runner gets the lock first applies; the +/// rest skip without crashing on `CREATE TABLE` (no `IF NOT EXISTS`) or on +/// the `schema_migrations.name` PRIMARY KEY. +fn replay_migrations(conn: &mut Connection) -> AppResult<()> { + for (name, sql) in EMBEDDED.iter() { + let tx = conn.transaction_with_behavior(rusqlite::TransactionBehavior::Immediate)?; + + let already_applied: i64 = tx.query_row( + "SELECT COUNT(*) FROM schema_migrations WHERE name = ?1", + params![name], + |row| row.get(0), + )?; + if already_applied > 0 { + tx.commit()?; + continue; + } + + tx.execute_batch(sql) + .map_err(|err| AppError::Database(format!("migration {name} failed: {err}")))?; + tx.execute( + "INSERT INTO schema_migrations (name) VALUES (?1)", + params![name], + )?; + tx.commit()?; + } + Ok(()) +} + fn applied_migrations(conn: &Connection) -> AppResult> { let mut stmt = conn.prepare("SELECT name FROM schema_migrations")?; let rows = stmt.query_map([], |row| row.get::<_, String>(0))?; diff --git a/apps/desktop-tauri/src-tauri/tests/migrations_test.rs b/apps/desktop-tauri/src-tauri/tests/migrations_test.rs index 85c27b9b5..134a481da 100644 --- a/apps/desktop-tauri/src-tauri/tests/migrations_test.rs +++ b/apps/desktop-tauri/src-tauri/tests/migrations_test.rs @@ -680,3 +680,123 @@ fn calendar_binding_roundtrip() { assert_eq!(b.writeback_mode, "two-way"); assert!(b.remote_version.is_none()); } + +#[test] +fn apply_pending_restores_fk_state_on_migration_failure() { + // Regression test for bug where a mid-replay migration error returned + // early without restoring the connection-scoped FK pragma. apply_pending + // toggles foreign_keys = OFF for the rebuild migrations (see + // rebuild_migrations_preserve_rows_when_fk_enforcement_is_on); if a + // migration fails after that toggle, the early `?` return left the + // connection with FK enforcement off. Subsequent application code + // sharing the same connection (Db wraps it in Arc>) + // would silently write child rows that violate referential integrity. + let mut conn = Connection::open_in_memory().unwrap(); + conn.execute_batch("PRAGMA foreign_keys = ON").unwrap(); + + // Apply migration 0000 directly so the schema is at v0; we want 0001 + // to fail when apply_pending tries to replay it. + migrations::bootstrap(&mut conn).unwrap(); + let (name_0000, sql_0000) = migrations::EMBEDDED[0]; + let tx = conn.transaction().unwrap(); + tx.execute_batch(sql_0000).unwrap(); + tx.execute( + "INSERT INTO schema_migrations (name) VALUES (?1)", + rusqlite::params![name_0000], + ) + .unwrap(); + tx.commit().unwrap(); + + // Pre-create `bookmarks` with a conflicting schema. Migration 0001's + // `CREATE TABLE bookmarks` (no IF NOT EXISTS) will fail. + conn.execute_batch("CREATE TABLE bookmarks (foo TEXT)") + .unwrap(); + + let fk_before: i64 = conn + .query_row("PRAGMA foreign_keys", [], |row| row.get(0)) + .unwrap(); + assert_eq!(fk_before, 1, "precondition: FK enforcement must be on"); + + let result = migrations::apply_pending(&mut conn); + assert!( + result.is_err(), + "expected migration 0001 to fail due to schema collision, got {result:?}" + ); + + let fk_after: i64 = conn + .query_row("PRAGMA foreign_keys", [], |row| row.get(0)) + .unwrap(); + assert_eq!( + fk_after, 1, + "PRAGMA foreign_keys must be restored to ON after a failed migration replay" + ); +} + +#[test] +fn apply_pending_is_safe_under_concurrent_runners() { + // Regression test for a race where two concurrent app processes + // (e.g. dev hot-reload, double-launch) both compute the same `pending` + // list before either records its writes. Without serialization, the + // second runner replays already-applied migrations and crashes on + // non-`IF NOT EXISTS` DDL (0001 `CREATE TABLE bookmarks`) or on the + // PRIMARY KEY conflict in `schema_migrations`. The fix re-checks + // applied state inside an IMMEDIATE per-migration transaction. + use std::sync::{Arc, Barrier}; + use std::thread; + + let dir = tempfile::tempdir().unwrap(); + let path = dir.path().join("data.db"); + + // Bring the file into existence and set WAL on a single setup + // connection so worker threads don't race on the PRAGMA write. + { + let setup = Connection::open(&path).unwrap(); + setup + .execute_batch("PRAGMA journal_mode = WAL;") + .unwrap(); + } + + let barrier = Arc::new(Barrier::new(2)); + + let path1 = path.clone(); + let b1 = barrier.clone(); + let h1 = thread::spawn(move || { + let mut conn = Connection::open(&path1).unwrap(); + conn.execute_batch("PRAGMA busy_timeout = 5000;").unwrap(); + b1.wait(); + migrations::apply_pending(&mut conn) + }); + + let path2 = path.clone(); + let b2 = barrier.clone(); + let h2 = thread::spawn(move || { + let mut conn = Connection::open(&path2).unwrap(); + conn.execute_batch("PRAGMA busy_timeout = 5000;").unwrap(); + b2.wait(); + migrations::apply_pending(&mut conn) + }); + + let r1 = h1.join().unwrap(); + let r2 = h2.join().unwrap(); + + assert!(r1.is_ok(), "thread 1 apply_pending failed: {r1:?}"); + assert!(r2.is_ok(), "thread 2 apply_pending failed: {r2:?}"); + + let conn = Connection::open(&path).unwrap(); + let names: Vec = conn + .prepare("SELECT name FROM schema_migrations ORDER BY name") + .unwrap() + .query_map([], |row| row.get::<_, String>(0)) + .unwrap() + .collect::>() + .unwrap(); + + let expected_count = migrations::EMBEDDED.len(); + assert_eq!( + names.len(), + expected_count, + "schema_migrations should have {expected_count} entries (one per migration), \ + got {} — duplicates indicate a concurrent insert slipped through: {names:?}", + names.len() + ); +} From 7a712d1dfa8e0df33a3de0e3e225863e24a1ea17 Mon Sep 17 00:00:00 2001 From: Kaan Karaca Date: Sun, 26 Apr 2026 00:32:51 +0300 Subject: [PATCH 17/25] m2(db): add sync_{queue,devices,state,history}/search_reasons structs --- apps/desktop-tauri/src-tauri/src/db/mod.rs | 5 + .../src-tauri/src/db/search_reasons.rs | 27 ++++ .../src-tauri/src/db/sync_devices.rs | 31 ++++ .../src-tauri/src/db/sync_history.rs | 28 ++++ .../src-tauri/src/db/sync_queue.rs | 34 ++++ .../src-tauri/src/db/sync_state.rs | 19 +++ .../src-tauri/tests/migrations_test.rs | 150 ++++++++++++++++++ 7 files changed, 294 insertions(+) create mode 100644 apps/desktop-tauri/src-tauri/src/db/search_reasons.rs create mode 100644 apps/desktop-tauri/src-tauri/src/db/sync_devices.rs create mode 100644 apps/desktop-tauri/src-tauri/src/db/sync_history.rs create mode 100644 apps/desktop-tauri/src-tauri/src/db/sync_queue.rs create mode 100644 apps/desktop-tauri/src-tauri/src/db/sync_state.rs diff --git a/apps/desktop-tauri/src-tauri/src/db/mod.rs b/apps/desktop-tauri/src-tauri/src/db/mod.rs index 47bd48df7..82bd2197f 100644 --- a/apps/desktop-tauri/src-tauri/src/db/mod.rs +++ b/apps/desktop-tauri/src-tauri/src/db/mod.rs @@ -21,7 +21,12 @@ pub mod note_positions; pub mod notes_cache; pub mod projects; pub mod reminders; +pub mod search_reasons; pub mod statuses; +pub mod sync_devices; +pub mod sync_history; +pub mod sync_queue; +pub mod sync_state; pub mod tag_definitions; pub mod tasks; diff --git a/apps/desktop-tauri/src-tauri/src/db/search_reasons.rs b/apps/desktop-tauri/src-tauri/src/db/search_reasons.rs new file mode 100644 index 000000000..473460d5e --- /dev/null +++ b/apps/desktop-tauri/src-tauri/src/db/search_reasons.rs @@ -0,0 +1,27 @@ +use serde::{Deserialize, Serialize}; + +#[derive(Debug, Clone, Serialize, Deserialize, specta::Type)] +#[serde(rename_all = "camelCase")] +pub struct SearchReason { + pub id: String, + pub item_id: String, + pub item_type: String, + pub item_title: String, + pub item_icon: Option, + pub search_query: String, + pub visited_at: String, +} + +impl SearchReason { + pub fn from_row(row: &rusqlite::Row<'_>) -> rusqlite::Result { + Ok(Self { + id: row.get("id")?, + item_id: row.get("item_id")?, + item_type: row.get("item_type")?, + item_title: row.get("item_title")?, + item_icon: row.get("item_icon")?, + search_query: row.get("search_query")?, + visited_at: row.get("visited_at")?, + }) + } +} diff --git a/apps/desktop-tauri/src-tauri/src/db/sync_devices.rs b/apps/desktop-tauri/src-tauri/src/db/sync_devices.rs new file mode 100644 index 000000000..dd4f529dd --- /dev/null +++ b/apps/desktop-tauri/src-tauri/src/db/sync_devices.rs @@ -0,0 +1,31 @@ +use serde::{Deserialize, Serialize}; + +#[derive(Debug, Clone, Serialize, Deserialize, specta::Type)] +#[serde(rename_all = "camelCase")] +pub struct SyncDevice { + pub id: String, + pub name: String, + pub platform: String, + pub os_version: Option, + pub app_version: String, + pub linked_at: i64, + pub last_sync_at: Option, + pub is_current_device: bool, + pub signing_public_key: String, +} + +impl SyncDevice { + pub fn from_row(row: &rusqlite::Row<'_>) -> rusqlite::Result { + Ok(Self { + id: row.get("id")?, + name: row.get("name")?, + platform: row.get("platform")?, + os_version: row.get("os_version")?, + app_version: row.get("app_version")?, + linked_at: row.get("linked_at")?, + last_sync_at: row.get("last_sync_at")?, + is_current_device: row.get::<_, i64>("is_current_device")? != 0, + signing_public_key: row.get("signing_public_key")?, + }) + } +} diff --git a/apps/desktop-tauri/src-tauri/src/db/sync_history.rs b/apps/desktop-tauri/src-tauri/src/db/sync_history.rs new file mode 100644 index 000000000..d95532a17 --- /dev/null +++ b/apps/desktop-tauri/src-tauri/src/db/sync_history.rs @@ -0,0 +1,28 @@ +use serde::{Deserialize, Serialize}; + +#[derive(Debug, Clone, Serialize, Deserialize, specta::Type)] +#[serde(rename_all = "camelCase")] +pub struct SyncHistoryEntry { + pub id: String, + #[serde(rename = "type")] + pub r#type: String, + pub item_count: i64, + pub direction: Option, + pub details: Option, + pub duration_ms: Option, + pub created_at: i64, +} + +impl SyncHistoryEntry { + pub fn from_row(row: &rusqlite::Row<'_>) -> rusqlite::Result { + Ok(Self { + id: row.get("id")?, + r#type: row.get("type")?, + item_count: row.get("item_count")?, + direction: row.get("direction")?, + details: row.get("details")?, + duration_ms: row.get("duration_ms")?, + created_at: row.get("created_at")?, + }) + } +} diff --git a/apps/desktop-tauri/src-tauri/src/db/sync_queue.rs b/apps/desktop-tauri/src-tauri/src/db/sync_queue.rs new file mode 100644 index 000000000..3526bdc23 --- /dev/null +++ b/apps/desktop-tauri/src-tauri/src/db/sync_queue.rs @@ -0,0 +1,34 @@ +use serde::{Deserialize, Serialize}; + +#[derive(Debug, Clone, Serialize, Deserialize, specta::Type)] +#[serde(rename_all = "camelCase")] +pub struct SyncQueueItem { + pub id: String, + #[serde(rename = "type")] + pub r#type: String, + pub item_id: String, + pub operation: String, + pub payload: String, + pub priority: i64, + pub attempts: i64, + pub last_attempt: Option, + pub error_message: Option, + pub created_at: i64, +} + +impl SyncQueueItem { + pub fn from_row(row: &rusqlite::Row<'_>) -> rusqlite::Result { + Ok(Self { + id: row.get("id")?, + r#type: row.get("type")?, + item_id: row.get("item_id")?, + operation: row.get("operation")?, + payload: row.get("payload")?, + priority: row.get("priority")?, + attempts: row.get("attempts")?, + last_attempt: row.get("last_attempt")?, + error_message: row.get("error_message")?, + created_at: row.get("created_at")?, + }) + } +} diff --git a/apps/desktop-tauri/src-tauri/src/db/sync_state.rs b/apps/desktop-tauri/src-tauri/src/db/sync_state.rs new file mode 100644 index 000000000..cadabdbd9 --- /dev/null +++ b/apps/desktop-tauri/src-tauri/src/db/sync_state.rs @@ -0,0 +1,19 @@ +use serde::{Deserialize, Serialize}; + +#[derive(Debug, Clone, Serialize, Deserialize, specta::Type)] +#[serde(rename_all = "camelCase")] +pub struct SyncState { + pub key: String, + pub value: String, + pub updated_at: i64, +} + +impl SyncState { + pub fn from_row(row: &rusqlite::Row<'_>) -> rusqlite::Result { + Ok(Self { + key: row.get("key")?, + value: row.get("value")?, + updated_at: row.get("updated_at")?, + }) + } +} diff --git a/apps/desktop-tauri/src-tauri/tests/migrations_test.rs b/apps/desktop-tauri/src-tauri/tests/migrations_test.rs index 134a481da..eac762a70 100644 --- a/apps/desktop-tauri/src-tauri/tests/migrations_test.rs +++ b/apps/desktop-tauri/src-tauri/tests/migrations_test.rs @@ -681,6 +681,156 @@ fn calendar_binding_roundtrip() { assert!(b.remote_version.is_none()); } +#[test] +fn sync_queue_item_roundtrip() { + let db = memry_desktop_tauri_lib::db::Db::open_memory().unwrap(); + let conn = db.conn().unwrap(); + + conn.execute( + "INSERT INTO sync_queue (id, type, item_id, operation, payload, created_at) \ + VALUES (?1, ?2, ?3, ?4, ?5, ?6)", + rusqlite::params!["q1", "task", "t1", "update", "{\"title\":\"x\"}", 1714003200000_i64], + ) + .unwrap(); + + let item = conn + .query_row( + "SELECT * FROM sync_queue WHERE id = 'q1'", + [], + memry_desktop_tauri_lib::db::sync_queue::SyncQueueItem::from_row, + ) + .unwrap(); + assert_eq!(item.id, "q1"); + assert_eq!(item.r#type, "task"); + assert_eq!(item.item_id, "t1"); + assert_eq!(item.operation, "update"); + assert_eq!(item.payload, "{\"title\":\"x\"}"); + assert_eq!(item.priority, 0); + assert_eq!(item.attempts, 0); + assert_eq!(item.created_at, 1714003200000); + assert!(item.last_attempt.is_none()); + assert!(item.error_message.is_none()); +} + +#[test] +fn sync_device_roundtrip() { + let db = memry_desktop_tauri_lib::db::Db::open_memory().unwrap(); + let conn = db.conn().unwrap(); + + conn.execute( + "INSERT INTO sync_devices \ + (id, name, platform, app_version, linked_at, is_current_device, signing_public_key) \ + VALUES (?1, ?2, ?3, ?4, ?5, ?6, ?7)", + rusqlite::params![ + "d1", + "Kaan's MacBook", + "macos", + "0.1.0", + 1714003200000_i64, + 1, + "ed25519-pubkey-base64", + ], + ) + .unwrap(); + + let dev = conn + .query_row( + "SELECT * FROM sync_devices WHERE id = 'd1'", + [], + memry_desktop_tauri_lib::db::sync_devices::SyncDevice::from_row, + ) + .unwrap(); + assert_eq!(dev.id, "d1"); + assert_eq!(dev.name, "Kaan's MacBook"); + assert_eq!(dev.platform, "macos"); + assert_eq!(dev.app_version, "0.1.0"); + assert_eq!(dev.linked_at, 1714003200000); + assert!(dev.is_current_device); + assert_eq!(dev.signing_public_key, "ed25519-pubkey-base64"); + assert!(dev.os_version.is_none()); + assert!(dev.last_sync_at.is_none()); +} + +#[test] +fn sync_state_roundtrip() { + let db = memry_desktop_tauri_lib::db::Db::open_memory().unwrap(); + let conn = db.conn().unwrap(); + + conn.execute( + "INSERT INTO sync_state (key, value, updated_at) VALUES (?1, ?2, ?3)", + rusqlite::params!["server_cursor", "abc123", 1714003200000_i64], + ) + .unwrap(); + + let s = conn + .query_row( + "SELECT * FROM sync_state WHERE key = 'server_cursor'", + [], + memry_desktop_tauri_lib::db::sync_state::SyncState::from_row, + ) + .unwrap(); + assert_eq!(s.key, "server_cursor"); + assert_eq!(s.value, "abc123"); + assert_eq!(s.updated_at, 1714003200000); +} + +#[test] +fn sync_history_entry_roundtrip() { + let db = memry_desktop_tauri_lib::db::Db::open_memory().unwrap(); + let conn = db.conn().unwrap(); + + conn.execute( + "INSERT INTO sync_history (id, type, item_count, direction, created_at) \ + VALUES (?1, ?2, ?3, ?4, ?5)", + rusqlite::params!["h1", "tasks", 42, "pull", 1714003200000_i64], + ) + .unwrap(); + + let h = conn + .query_row( + "SELECT * FROM sync_history WHERE id = 'h1'", + [], + memry_desktop_tauri_lib::db::sync_history::SyncHistoryEntry::from_row, + ) + .unwrap(); + assert_eq!(h.id, "h1"); + assert_eq!(h.r#type, "tasks"); + assert_eq!(h.item_count, 42); + assert_eq!(h.direction.as_deref(), Some("pull")); + assert_eq!(h.created_at, 1714003200000); + assert!(h.details.is_none()); + assert!(h.duration_ms.is_none()); +} + +#[test] +fn search_reason_roundtrip() { + let db = memry_desktop_tauri_lib::db::Db::open_memory().unwrap(); + let conn = db.conn().unwrap(); + + conn.execute( + "INSERT INTO search_reasons \ + (id, item_id, item_type, item_title, search_query) \ + VALUES (?1, ?2, ?3, ?4, ?5)", + rusqlite::params!["sr1", "n42", "note", "Hello world", "hello"], + ) + .unwrap(); + + let r = conn + .query_row( + "SELECT * FROM search_reasons WHERE id = 'sr1'", + [], + memry_desktop_tauri_lib::db::search_reasons::SearchReason::from_row, + ) + .unwrap(); + assert_eq!(r.id, "sr1"); + assert_eq!(r.item_id, "n42"); + assert_eq!(r.item_type, "note"); + assert_eq!(r.item_title, "Hello world"); + assert_eq!(r.search_query, "hello"); + assert!(r.item_icon.is_none()); + assert!(!r.visited_at.is_empty()); +} + #[test] fn apply_pending_restores_fk_state_on_migration_failure() { // Regression test for bug where a mid-replay migration error returned From 316e0f184033ecc3d7959d63f2ecb822f8caac71 Mon Sep 17 00:00:00 2001 From: Kaan Karaca Date: Sun, 26 Apr 2026 00:52:12 +0300 Subject: [PATCH 18/25] m2(settings): settings_get/set/list commands + 5 Rust tests Adds the first real feature-domain IPC slice: a thin Setting KV store backed by SQLite via three Tauri commands. - db/settings.rs: get/set/list helpers with UPSERT semantics matching the 0018 schema (key TEXT PRIMARY KEY, value TEXT, modified_at strftime'd). - db/saved_filters.rs: SavedFilter struct + from_row mapper, present so the Phase F bindings stress-test exercises it without yet needing CRUD. - commands/settings.rs: 3 #[tauri::command] + #[specta::specta] handlers, thin adapters over the db layer with input structs gated on rename_all = camelCase. - lib.rs: invoke_handler! registers the 3 commands directly so the acceptance grep that scans lib.rs for settings::settings_* hits. - tests/settings_test.rs (test-helpers gated): 5 cases covering missing key, roundtrip, upsert, sorted list, and Turkish-character UTF-8 integrity through rusqlite TEXT. Mock router stays in place for every other settings_* route; only settings_get/set/list will flip to real Tauri once Task 15 lands. --- apps/desktop-tauri/src-tauri/Cargo.toml | 4 ++ .../src-tauri/src/commands/mod.rs | 18 +++--- .../src-tauri/src/commands/settings.rs | 41 +++++++++++++ apps/desktop-tauri/src-tauri/src/db/mod.rs | 2 + .../src-tauri/src/db/saved_filters.rs | 27 +++++++++ .../src-tauri/src/db/settings.rs | 57 +++++++++++++++++++ apps/desktop-tauri/src-tauri/src/lib.rs | 13 +++-- .../src-tauri/tests/settings_test.rs | 44 ++++++++++++++ 8 files changed, 191 insertions(+), 15 deletions(-) create mode 100644 apps/desktop-tauri/src-tauri/src/commands/settings.rs create mode 100644 apps/desktop-tauri/src-tauri/src/db/saved_filters.rs create mode 100644 apps/desktop-tauri/src-tauri/src/db/settings.rs create mode 100644 apps/desktop-tauri/src-tauri/tests/settings_test.rs diff --git a/apps/desktop-tauri/src-tauri/Cargo.toml b/apps/desktop-tauri/src-tauri/Cargo.toml index c2a8c69ee..dceff0132 100644 --- a/apps/desktop-tauri/src-tauri/Cargo.toml +++ b/apps/desktop-tauri/src-tauri/Cargo.toml @@ -47,3 +47,7 @@ path = "src/bin/generate_bindings.rs" [[test]] name = "migrations_test" required-features = ["test-helpers"] + +[[test]] +name = "settings_test" +required-features = ["test-helpers"] diff --git a/apps/desktop-tauri/src-tauri/src/commands/mod.rs b/apps/desktop-tauri/src-tauri/src/commands/mod.rs index 9fe626c55..90fab4db0 100644 --- a/apps/desktop-tauri/src-tauri/src/commands/mod.rs +++ b/apps/desktop-tauri/src-tauri/src/commands/mod.rs @@ -1,13 +1,11 @@ //! IPC command surface exposed to the renderer. //! -//! At M1 no commands are implemented — the renderer is fed by the JS-side -//! mock router in `src/lib/ipc/mocks/`. M2+ introduces real commands per -//! domain (notes, tasks, crypto, sync, etc.). When a domain's Rust -//! implementation lands, entries are added here and the corresponding -//! mock entry is removed from `src/lib/ipc/invoke.ts`'s realCommands set. +//! Phase F (M2) introduces the first real feature-domain slice — settings — +//! crossing the boundary via `settings_get` / `settings_set` / `settings_list`. +//! Every other domain still serves data through the JS-side mock router in +//! `src/lib/ipc/mocks/`. As each domain's Rust implementation lands, declare +//! its module here and add the command names to the `generate_handler!` macro +//! invocation in `lib.rs::run` plus `realCommands` in +//! `src/lib/ipc/invoke.ts`. -use tauri::Builder; - -pub fn register(builder: Builder) -> Builder { - builder.invoke_handler(tauri::generate_handler![]) -} +pub mod settings; diff --git a/apps/desktop-tauri/src-tauri/src/commands/settings.rs b/apps/desktop-tauri/src-tauri/src/commands/settings.rs new file mode 100644 index 000000000..6a1b30fd3 --- /dev/null +++ b/apps/desktop-tauri/src-tauri/src/commands/settings.rs @@ -0,0 +1,41 @@ +use crate::app_state::AppState; +use crate::db::settings::{self, Setting}; +use crate::error::AppResult; +use serde::Deserialize; + +#[derive(Debug, Deserialize, specta::Type)] +#[serde(rename_all = "camelCase")] +pub struct SettingsGetInput { + pub key: String, +} + +#[derive(Debug, Deserialize, specta::Type)] +#[serde(rename_all = "camelCase")] +pub struct SettingsSetInput { + pub key: String, + pub value: String, +} + +#[tauri::command] +#[specta::specta] +pub async fn settings_get( + state: tauri::State<'_, AppState>, + input: SettingsGetInput, +) -> AppResult> { + settings::get(&state.db, &input.key) +} + +#[tauri::command] +#[specta::specta] +pub async fn settings_set( + state: tauri::State<'_, AppState>, + input: SettingsSetInput, +) -> AppResult<()> { + settings::set(&state.db, &input.key, &input.value) +} + +#[tauri::command] +#[specta::specta] +pub async fn settings_list(state: tauri::State<'_, AppState>) -> AppResult> { + settings::list(&state.db) +} diff --git a/apps/desktop-tauri/src-tauri/src/db/mod.rs b/apps/desktop-tauri/src-tauri/src/db/mod.rs index 82bd2197f..4c775c7ad 100644 --- a/apps/desktop-tauri/src-tauri/src/db/mod.rs +++ b/apps/desktop-tauri/src-tauri/src/db/mod.rs @@ -21,7 +21,9 @@ pub mod note_positions; pub mod notes_cache; pub mod projects; pub mod reminders; +pub mod saved_filters; pub mod search_reasons; +pub mod settings; pub mod statuses; pub mod sync_devices; pub mod sync_history; diff --git a/apps/desktop-tauri/src-tauri/src/db/saved_filters.rs b/apps/desktop-tauri/src-tauri/src/db/saved_filters.rs new file mode 100644 index 000000000..380432b19 --- /dev/null +++ b/apps/desktop-tauri/src-tauri/src/db/saved_filters.rs @@ -0,0 +1,27 @@ +use serde::{Deserialize, Serialize}; + +#[derive(Debug, Clone, Serialize, Deserialize, specta::Type)] +#[serde(rename_all = "camelCase")] +pub struct SavedFilter { + pub id: String, + pub name: String, + pub config: String, + pub position: i64, + pub created_at: String, + pub clock: Option, + pub synced_at: Option, +} + +impl SavedFilter { + pub fn from_row(row: &rusqlite::Row<'_>) -> rusqlite::Result { + Ok(Self { + id: row.get("id")?, + name: row.get("name")?, + config: row.get("config")?, + position: row.get("position")?, + created_at: row.get("created_at")?, + clock: row.get("clock")?, + synced_at: row.get("synced_at")?, + }) + } +} diff --git a/apps/desktop-tauri/src-tauri/src/db/settings.rs b/apps/desktop-tauri/src-tauri/src/db/settings.rs new file mode 100644 index 000000000..841025c77 --- /dev/null +++ b/apps/desktop-tauri/src-tauri/src/db/settings.rs @@ -0,0 +1,57 @@ +use crate::db::Db; +use crate::error::{AppError, AppResult}; +use serde::{Deserialize, Serialize}; + +#[derive(Debug, Clone, Serialize, Deserialize, specta::Type)] +#[serde(rename_all = "camelCase")] +pub struct Setting { + pub key: String, + pub value: String, + pub modified_at: String, +} + +impl Setting { + pub fn from_row(row: &rusqlite::Row<'_>) -> rusqlite::Result { + Ok(Self { + key: row.get("key")?, + value: row.get("value")?, + modified_at: row.get("modified_at")?, + }) + } +} + +pub fn get(db: &Db, key: &str) -> AppResult> { + let conn = db.conn()?; + let result = conn.query_row( + "SELECT value FROM settings WHERE key = ?1", + rusqlite::params![key], + |row| row.get::<_, String>(0), + ); + match result { + Ok(v) => Ok(Some(v)), + Err(rusqlite::Error::QueryReturnedNoRows) => Ok(None), + Err(e) => Err(AppError::from(e)), + } +} + +pub fn set(db: &Db, key: &str, value: &str) -> AppResult<()> { + let conn = db.conn()?; + conn.execute( + "INSERT INTO settings (key, value) VALUES (?1, ?2) + ON CONFLICT(key) DO UPDATE SET + value = excluded.value, + modified_at = strftime('%Y-%m-%dT%H:%M:%fZ', 'now')", + rusqlite::params![key, value], + )?; + Ok(()) +} + +pub fn list(db: &Db) -> AppResult> { + let conn = db.conn()?; + let mut stmt = conn.prepare("SELECT key, value, modified_at FROM settings ORDER BY key")?; + let items = stmt + .query_map([], Setting::from_row)? + .filter_map(Result::ok) + .collect(); + Ok(items) +} diff --git a/apps/desktop-tauri/src-tauri/src/lib.rs b/apps/desktop-tauri/src-tauri/src/lib.rs index 2b6985e36..7737dfb3b 100644 --- a/apps/desktop-tauri/src-tauri/src/lib.rs +++ b/apps/desktop-tauri/src-tauri/src/lib.rs @@ -29,7 +29,7 @@ fn init_app_state() -> AppResult { #[cfg_attr(mobile, tauri::mobile_entry_point)] pub fn run() { let app_state = init_app_state().expect("failed to initialize app state"); - let builder = tauri::Builder::default() + tauri::Builder::default() .plugin(tauri_plugin_shell::init()) .manage(app_state) .setup(|_app| { @@ -40,11 +40,14 @@ pub fn run() { ) .json() .init(); - tracing::info!("memry desktop-tauri booting (m1 scaffold)"); + tracing::info!("memry desktop-tauri booting (m2 settings slice)"); Ok(()) - }); - - commands::register(builder) + }) + .invoke_handler(tauri::generate_handler![ + commands::settings::settings_get, + commands::settings::settings_set, + commands::settings::settings_list, + ]) .run(tauri::generate_context!()) .expect("error while running tauri application"); } diff --git a/apps/desktop-tauri/src-tauri/tests/settings_test.rs b/apps/desktop-tauri/src-tauri/tests/settings_test.rs new file mode 100644 index 000000000..ef14b5106 --- /dev/null +++ b/apps/desktop-tauri/src-tauri/tests/settings_test.rs @@ -0,0 +1,44 @@ +use memry_desktop_tauri_lib::db::{settings, Db}; + +#[test] +fn get_missing_key_returns_none() { + let db = Db::open_memory().unwrap(); + let v = settings::get(&db, "nonexistent").unwrap(); + assert_eq!(v, None); +} + +#[test] +fn set_then_get_roundtrip() { + let db = Db::open_memory().unwrap(); + settings::set(&db, "theme", "dark").unwrap(); + let v = settings::get(&db, "theme").unwrap(); + assert_eq!(v.as_deref(), Some("dark")); +} + +#[test] +fn set_upserts_existing_key() { + let db = Db::open_memory().unwrap(); + settings::set(&db, "theme", "dark").unwrap(); + settings::set(&db, "theme", "light").unwrap(); + let v = settings::get(&db, "theme").unwrap(); + assert_eq!(v.as_deref(), Some("light")); +} + +#[test] +fn list_returns_sorted_entries() { + let db = Db::open_memory().unwrap(); + settings::set(&db, "b-key", "2").unwrap(); + settings::set(&db, "a-key", "1").unwrap(); + settings::set(&db, "c-key", "3").unwrap(); + let items = settings::list(&db).unwrap(); + let keys: Vec<&str> = items.iter().map(|s| s.key.as_str()).collect(); + assert_eq!(keys, vec!["a-key", "b-key", "c-key"]); +} + +#[test] +fn set_and_get_preserve_utf8_multibyte_value() { + let db = Db::open_memory().unwrap(); + settings::set(&db, "general.label", "çalışma modu").unwrap(); + let v = settings::get(&db, "general.label").unwrap(); + assert_eq!(v.as_deref(), Some("çalışma modu")); +} From 99cfa010a217ff7110b011980ebd9041eed65764 Mon Sep 17 00:00:00 2001 From: Kaan Karaca Date: Sun, 26 Apr 2026 00:58:51 +0300 Subject: [PATCH 19/25] m2(bindings): regenerate with 22 domain types + settings commands MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Replaces the M1 stub generator with a tauri-specta Builder pipeline that emits TypeScript bindings for the full M2 domain surface plus the three settings commands. Adds specta-typescript as a direct dep so the generator binary can call Typescript::default(); previously it was only available as a transitive feature flag of tauri-specta and unreachable from our bin. Output (354 lines): - 1 commands const with settingsGet/settingsSet/settingsList wrappers that return tauri-specta's typed Result envelope - AppError discriminated union (kind + message tag/content) - 22 domain types (Bookmark, Calendar*, FolderConfig, InboxItem, NoteMetadata, NotePosition, Project, PropertyDefinition, Reminder, SavedFilter, SearchReason, Setting, Status, Sync*, TagDefinition, Task) - 2 input types for settings commands - typedError runtime helper camelCase rename hygiene verified: no created_at/modified_at/project_id fields leak through. The bindings:generate + bindings:check pipeline runs cargo against the generator bin to keep the file deterministic; the checked-in copy now matches a fresh regeneration. Renderer typecheck stays clean — nothing imports from @/generated/bindings yet. Phase F Task 15 hooks the Setting type up via the useSettings slice. --- apps/desktop-tauri/src-tauri/Cargo.toml | 1 + .../src-tauri/src/bin/generate_bindings.rs | 64 +++- apps/desktop-tauri/src/generated/bindings.ts | 362 +++++++++++++++++- 3 files changed, 400 insertions(+), 27 deletions(-) diff --git a/apps/desktop-tauri/src-tauri/Cargo.toml b/apps/desktop-tauri/src-tauri/Cargo.toml index dceff0132..c25d06d93 100644 --- a/apps/desktop-tauri/src-tauri/Cargo.toml +++ b/apps/desktop-tauri/src-tauri/Cargo.toml @@ -31,6 +31,7 @@ serde_json = "1.0" thiserror = "2.0" directories = "5" specta = { version = "2.0.0-rc.20", features = ["derive"] } +specta-typescript = "0.0.11" tauri-specta = { version = "2.0.0-rc.21", features = ["typescript"] } [features] diff --git a/apps/desktop-tauri/src-tauri/src/bin/generate_bindings.rs b/apps/desktop-tauri/src-tauri/src/bin/generate_bindings.rs index 29d096d6b..b5af60929 100644 --- a/apps/desktop-tauri/src-tauri/src/bin/generate_bindings.rs +++ b/apps/desktop-tauri/src-tauri/src/bin/generate_bindings.rs @@ -1,25 +1,51 @@ -//! Writes TypeScript bindings for Tauri commands into the renderer. +//! Regenerate `src/generated/bindings.ts` from Rust command signatures +//! and domain struct derives. Run via `pnpm bindings:generate`. //! -//! At M1 there are no commands; this binary is a no-op stub. M2+ updates -//! this with `specta::ts::export_named_datatypes` once domain structs and -//! commands exist. +//! The Phase F surface is a stress test: every `db/*` struct that derives +//! `specta::Type` is registered here so a typo or missing rename_all in any +//! domain module surfaces in the generated TS file. The 3 Tauri commands +//! exposed today (`settings_get`/`settings_set`/`settings_list`) are +//! collected via `collect_commands!`; subsequent milestones extend both +//! lists as their Rust implementations land. -use std::fs; -use std::path::PathBuf; +use memry_desktop_tauri_lib::commands; +use memry_desktop_tauri_lib::db; +use memry_desktop_tauri_lib::error::AppError; +use specta_typescript::Typescript; +use tauri_specta::{collect_commands, Builder}; -fn main() { - let output = PathBuf::from("../src/generated/bindings.ts"); +fn main() -> Result<(), Box> { + let builder = Builder::::new() + .commands(collect_commands![ + commands::settings::settings_get, + commands::settings::settings_set, + commands::settings::settings_list, + ]) + .typ::() + .typ::() + .typ::() + .typ::() + .typ::() + .typ::() + .typ::() + .typ::() + .typ::() + .typ::() + .typ::() + .typ::() + .typ::() + .typ::() + .typ::() + .typ::() + .typ::() + .typ::() + .typ::() + .typ::() + .typ::() + .typ::() + .typ::(); - let contents = r#"// !! AUTO-GENERATED BY `pnpm bindings:generate` !! -// Do not edit this file manually. It is regenerated from Rust command -// signatures in apps/desktop-tauri/src-tauri/src/commands/. -// -// At M1 there are no commands yet; this file is an empty export to preserve -// the import path for consumers. Subsequent milestones replace contents. + builder.export(Typescript::default(), "../src/generated/bindings.ts")?; -export {} -"#; - - fs::write(&output, contents).expect("failed to write bindings"); - println!("Wrote bindings to {}", output.display()); + Ok(()) } diff --git a/apps/desktop-tauri/src/generated/bindings.ts b/apps/desktop-tauri/src/generated/bindings.ts index dd2741789..b1621fc9f 100644 --- a/apps/desktop-tauri/src/generated/bindings.ts +++ b/apps/desktop-tauri/src/generated/bindings.ts @@ -1,8 +1,354 @@ -// !! AUTO-GENERATED BY `pnpm bindings:generate` !! -// Do not edit this file manually. It is regenerated from Rust command -// signatures in apps/desktop-tauri/src-tauri/src/commands/. -// -// At M1 there are no commands yet; this file is an empty export to preserve -// the import path for consumers. Subsequent milestones replace contents. - -export {} +// This file has been generated by Tauri Specta. Do not edit this file manually. + +import { invoke as __TAURI_INVOKE } from "@tauri-apps/api/core"; + +/** Commands */ +export const commands = { + settingsGet: (input: SettingsGetInput) => typedError(__TAURI_INVOKE("settings_get", { input })), + settingsSet: (input: SettingsSetInput) => typedError(__TAURI_INVOKE("settings_set", { input })), + settingsList: () => typedError(__TAURI_INVOKE("settings_list")), +}; + +/* Types */ +export type AppError = { kind: "Database"; message: string } | { kind: "Crypto"; message: string } | { kind: "VaultLocked" } | { kind: "InvalidPassword" } | { kind: "NotFound"; message: string } | { kind: "Network"; message: string } | { kind: "Conflict"; message: string } | { kind: "Validation"; message: string } | { kind: "Internal"; message: string }; + +export type Bookmark = { + id: string, + itemType: string, + itemId: string, + position: number, + createdAt: string, +}; + +export type CalendarBinding = { + id: string, + sourceType: string, + sourceId: string, + provider: string, + remoteCalendarId: string, + remoteEventId: string, + ownershipMode: string, + writebackMode: string, + remoteVersion: string | null, + lastLocalSnapshot: string | null, + archivedAt: string | null, + clock: string | null, + syncedAt: string | null, + createdAt: string, + modifiedAt: string, +}; + +export type CalendarEvent = { + id: string, + title: string, + description: string | null, + location: string | null, + startAt: string, + endAt: string | null, + timezone: string, + isAllDay: boolean, + recurrenceRule: string | null, + recurrenceExceptions: string | null, + archivedAt: string | null, + clock: string | null, + syncedAt: string | null, + createdAt: string, + modifiedAt: string, + targetCalendarId: string | null, + fieldClocks: string | null, + attendees: string | null, + reminders: string | null, + visibility: string | null, + colorId: string | null, + conferenceData: string | null, + parentEventId: string | null, + originalStartTime: string | null, +}; + +export type CalendarExternalEvent = { + id: string, + sourceId: string, + remoteEventId: string, + remoteEtag: string | null, + remoteUpdatedAt: string | null, + title: string, + description: string | null, + location: string | null, + startAt: string, + endAt: string | null, + timezone: string | null, + isAllDay: boolean, + status: string, + recurrenceRule: string | null, + rawPayload: string | null, + archivedAt: string | null, + clock: string | null, + syncedAt: string | null, + createdAt: string, + modifiedAt: string, + attendees: string | null, + reminders: string | null, + visibility: string | null, + colorId: string | null, + conferenceData: string | null, +}; + +export type CalendarSource = { + id: string, + provider: string, + kind: string, + accountId: string | null, + remoteId: string, + title: string, + timezone: string | null, + color: string | null, + isPrimary: boolean, + isSelected: boolean, + isMemryManaged: boolean, + syncCursor: string | null, + syncStatus: string, + lastSyncedAt: string | null, + metadata: string | null, + archivedAt: string | null, + clock: string | null, + syncedAt: string | null, + createdAt: string, + modifiedAt: string, + lastError: string | null, +}; + +export type FolderConfig = { + path: string, + icon: string | null, + clock: string | null, + createdAt: string, + modifiedAt: string, +}; + +export type InboxItem = { + id: string, + type: string, + title: string, + content: string | null, + createdAt: string, + modifiedAt: string, + filedAt: string | null, + filedTo: string | null, + filedAction: string | null, + snoozedUntil: string | null, + snoozeReason: string | null, + viewedAt: string | null, + processingStatus: string | null, + processingError: string | null, + metadata: string | null, + attachmentPath: string | null, + thumbnailPath: string | null, + transcription: string | null, + transcriptionStatus: string | null, + sourceUrl: string | null, + sourceTitle: string | null, + archivedAt: string | null, + clock: string | null, + syncedAt: string | null, + localOnly: boolean | null, + captureSource: string | null, +}; + +export type NoteMetadata = { + id: string, + path: string, + title: string, + emoji: string | null, + fileType: string, + mimeType: string | null, + fileSize: number | null, + attachmentId: string | null, + attachmentReferences: string | null, + localOnly: boolean, + syncPolicy: string, + journalDate: string | null, + propertyDefinitionNames: string | null, + clock: string | null, + syncedAt: string | null, + createdAt: string, + modifiedAt: string, + storedAt: string, +}; + +export type NotePosition = { + path: string, + folderPath: string, + position: number, +}; + +export type Project = { + id: string, + name: string, + description: string | null, + color: string, + icon: string | null, + position: number, + isInbox: boolean, + createdAt: string, + modifiedAt: string, + archivedAt: string | null, + clock: string | null, + fieldClocks: string | null, + syncedAt: string | null, +}; + +export type PropertyDefinition = { + name: string, + type: string, + options: string | null, + defaultValue: string | null, + color: string | null, + createdAt: string, +}; + +export type Reminder = { + id: string, + targetType: string, + targetId: string, + remindAt: string, + highlightText: string | null, + highlightStart: number | null, + highlightEnd: number | null, + title: string | null, + note: string | null, + status: string, + triggeredAt: string | null, + dismissedAt: string | null, + snoozedUntil: string | null, + createdAt: string, + modifiedAt: string, +}; + +export type SavedFilter = { + id: string, + name: string, + config: string, + position: number, + createdAt: string, + clock: string | null, + syncedAt: string | null, +}; + +export type SearchReason = { + id: string, + itemId: string, + itemType: string, + itemTitle: string, + itemIcon: string | null, + searchQuery: string, + visitedAt: string, +}; + +export type Setting = { + key: string, + value: string, + modifiedAt: string, +}; + +export type SettingsGetInput = { + key: string, +}; + +export type SettingsSetInput = { + key: string, + value: string, +}; + +export type Status = { + id: string, + projectId: string, + name: string, + color: string, + position: number, + isDefault: boolean, + isDone: boolean, + createdAt: string, +}; + +export type SyncDevice = { + id: string, + name: string, + platform: string, + osVersion: string | null, + appVersion: string, + linkedAt: number, + lastSyncAt: number | null, + isCurrentDevice: boolean, + signingPublicKey: string, +}; + +export type SyncHistoryEntry = { + id: string, + type: string, + itemCount: number, + direction: string | null, + details: string | null, + durationMs: number | null, + createdAt: number, +}; + +export type SyncQueueItem = { + id: string, + type: string, + itemId: string, + operation: string, + payload: string, + priority: number, + attempts: number, + lastAttempt: number | null, + errorMessage: string | null, + createdAt: number, +}; + +export type SyncState = { + key: string, + value: string, + updatedAt: number, +}; + +export type TagDefinition = { + name: string, + color: string, + clock: string | null, + createdAt: string, +}; + +export type Task = { + id: string, + projectId: string, + statusId: string | null, + parentId: string | null, + title: string, + description: string | null, + priority: number, + position: number, + dueDate: string | null, + dueTime: string | null, + startDate: string | null, + repeatConfig: string | null, + repeatFrom: string | null, + sourceNoteId: string | null, + completedAt: string | null, + archivedAt: string | null, + clock: string | null, + fieldClocks: string | null, + syncedAt: string | null, + createdAt: string, + modifiedAt: string, +}; + +/* Tauri Specta runtime */ +async function typedError(result: Promise): Promise<{ status: "ok"; data: T } | { status: "error"; error: E }> { + try { + return { status: "ok", data: await result }; + } catch (e) { + if (e instanceof Error) throw e; + return { status: "error", error: e as any }; + } +} + From 53b2cfcea4666090b2d4d406c18271b75323cb9b Mon Sep 17 00:00:00 2001 From: Kaan Karaca Date: Sun, 26 Apr 2026 01:09:02 +0300 Subject: [PATCH 20/25] m2(renderer): swap settings_* mock for real invoke; useSettings hook wired MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Phase F's renderer slice. The IPC wrapper now lights up the three settings commands while every other domain stays on the JS-side mock router. - src/lib/ipc/invoke.ts: realCommands set gains settings_get/set/list. The router gate stays untouched, so unrelated mocks (settings_get_section, settings_set_general_settings, calendar/journal/tab/AI groups, etc.) continue to serve their M1 mock shapes until each domain's Rust handler lands in a later milestone. - src/hooks/useSettings.ts: new file. Tanstack Query bindings for the three commands — useSetting(key) / useSettings() / useSetSetting() — typed against `Setting` from generated/bindings.ts. Mutation onSuccess invalidates the per-key + list query keys. - tests/useSettings.test.tsx: end-to-end roundtrip through the real invoke wrapper using a stubbed @tauri-apps/api/core. Follows invoke.test.ts's pattern of vi.unmock'ing @/lib/ipc/invoke first so we bypass the global setup's auto-mock and exercise the live shouldUseMock branching. Three cases: roundtrip, list reflection after mutation, null for unset key. Settings package residue removed from acceptance grep paths (src/lib/ipc/**, src/hooks/useSettings.ts, src/pages/settings/**) by rehoming the two type-only contracts touched by this slice into src/types/settings-schemas.ts: ShortcutBinding (used by pages/settings/shortcuts-section.tsx) and CalendarSettings (used by pages/settings/calendar-section.tsx). Deeper consumers in src/lib/ and src/hooks/ still import @memry/contracts/settings-schemas and travel forward via the Phase G carry-forward ledger. Manual dev smoke (toggle setting → sqlite3 confirms row) is PENDING — no UI consumer wires useSetting/useSetSetting yet. The hook + bindings + Rust path are already proven by 3 vitest cases + 5 cargo cases, but end-to-end UI verification waits on either Phase G's broader rollout or a one-off temporary toggle the user can drive. --- apps/desktop-tauri/src/hooks/useSettings.ts | 32 ++++++ apps/desktop-tauri/src/lib/ipc/invoke.ts | 10 +- .../src/pages/settings/calendar-section.tsx | 2 +- .../src/pages/settings/shortcuts-section.tsx | 2 +- .../src/types/settings-schemas.ts | 29 +++++ apps/desktop-tauri/tests/useSettings.test.tsx | 106 ++++++++++++++++++ 6 files changed, 175 insertions(+), 6 deletions(-) create mode 100644 apps/desktop-tauri/src/hooks/useSettings.ts create mode 100644 apps/desktop-tauri/src/types/settings-schemas.ts create mode 100644 apps/desktop-tauri/tests/useSettings.test.tsx diff --git a/apps/desktop-tauri/src/hooks/useSettings.ts b/apps/desktop-tauri/src/hooks/useSettings.ts new file mode 100644 index 000000000..aefdc838e --- /dev/null +++ b/apps/desktop-tauri/src/hooks/useSettings.ts @@ -0,0 +1,32 @@ +import { useMutation, useQuery, useQueryClient } from '@tanstack/react-query' +import { invoke } from '@/lib/ipc/invoke' +import type { Setting } from '@/generated/bindings' + +const settingsKey = (key: string) => ['settings', key] as const +const settingsListKey = ['settings', 'list'] as const + +export function useSetting(key: string) { + return useQuery({ + queryKey: settingsKey(key), + queryFn: () => invoke('settings_get', { input: { key } }) + }) +} + +export function useSettings() { + return useQuery({ + queryKey: settingsListKey, + queryFn: () => invoke('settings_list') + }) +} + +export function useSetSetting() { + const qc = useQueryClient() + return useMutation({ + mutationFn: ({ key, value }: { key: string; value: string }) => + invoke('settings_set', { input: { key, value } }), + onSuccess: (_, { key }) => { + qc.invalidateQueries({ queryKey: settingsKey(key) }) + qc.invalidateQueries({ queryKey: settingsListKey }) + } + }) +} diff --git a/apps/desktop-tauri/src/lib/ipc/invoke.ts b/apps/desktop-tauri/src/lib/ipc/invoke.ts index 22033b9ea..0553ea068 100644 --- a/apps/desktop-tauri/src/lib/ipc/invoke.ts +++ b/apps/desktop-tauri/src/lib/ipc/invoke.ts @@ -22,12 +22,14 @@ export async function invoke( /** * Decides whether a command should be served by the mock router or routed to - * the real Tauri backend. At M1, every command uses mock. Future milestones - * extend the `realCommands` set with commands whose Rust implementation has - * landed. + * the real Tauri backend. M2 Phase F lights up the settings KV slice; every + * other domain still serves data through the JS-side mocks until its Rust + * implementation lands. Add a command here once its Rust handler ships. */ const realCommands = new Set([ - // No real commands at M1 — all mocked. M2+ adds entries here. + 'settings_get', + 'settings_set', + 'settings_list' ]) function shouldUseMock(cmd: string): boolean { diff --git a/apps/desktop-tauri/src/pages/settings/calendar-section.tsx b/apps/desktop-tauri/src/pages/settings/calendar-section.tsx index 143c4fdad..66e09e4a7 100644 --- a/apps/desktop-tauri/src/pages/settings/calendar-section.tsx +++ b/apps/desktop-tauri/src/pages/settings/calendar-section.tsx @@ -14,7 +14,7 @@ import { SettingRow, COMPACT_SELECT } from '@/components/settings/settings-primitives' -import type { CalendarSettings } from '@memry/contracts/settings-schemas' +import type { CalendarSettings } from '@/types/settings-schemas' const GLOBAL_CLICK_OPTIONS = [ { value: 'journal', label: 'Open Journal' }, diff --git a/apps/desktop-tauri/src/pages/settings/shortcuts-section.tsx b/apps/desktop-tauri/src/pages/settings/shortcuts-section.tsx index 31f3852b8..61ec40845 100644 --- a/apps/desktop-tauri/src/pages/settings/shortcuts-section.tsx +++ b/apps/desktop-tauri/src/pages/settings/shortcuts-section.tsx @@ -6,7 +6,7 @@ import { Badge } from '@/components/ui/badge' import { Search, RotateCcw, X, AlertTriangle, Info } from '@/lib/icons' import { useKeyboardSettings } from '@/hooks/use-keyboard-settings' import { toast } from 'sonner' -import type { ShortcutBinding } from '@memry/contracts/settings-schemas' +import type { ShortcutBinding } from '@/types/settings-schemas' import type { ShortcutBindingDTO } from '@/types/preload-types' import { SHORTCUT_REGISTRY, diff --git a/apps/desktop-tauri/src/types/settings-schemas.ts b/apps/desktop-tauri/src/types/settings-schemas.ts new file mode 100644 index 000000000..6edf95688 --- /dev/null +++ b/apps/desktop-tauri/src/types/settings-schemas.ts @@ -0,0 +1,29 @@ +/** + * Settings type definitions used by the Tauri renderer. + * + * Phase F (M2) rehomes the narrow set of @memry/contracts/settings-schemas + * types directly touched by the real settings_* IPC slice (`useSettings` + * hook + acceptance grep paths). Other consumers in `src/lib/`, `src/hooks/`, + * and `src/types/preload-types.ts` still import from `@memry/contracts/*`; + * those references travel forward via the Phase G carry-forward ledger and + * land alongside their respective domain slices in later milestones. + * + * Types kept structurally identical to the upstream Zod-inferred shapes in + * packages/contracts/src/settings-schemas.ts so the local + package copies + * remain interchangeable wherever both flow through the same component tree. + */ + +export interface ShortcutBinding { + key: string + modifiers: { + meta?: boolean + ctrl?: boolean + shift?: boolean + alt?: boolean + } +} + +export interface CalendarSettings { + dayCellClickBehavior: 'journal' | 'calendar' + calendarPageClickOverride: 'inherit' | 'journal' | 'calendar' +} diff --git a/apps/desktop-tauri/tests/useSettings.test.tsx b/apps/desktop-tauri/tests/useSettings.test.tsx new file mode 100644 index 000000000..e9ece8aba --- /dev/null +++ b/apps/desktop-tauri/tests/useSettings.test.tsx @@ -0,0 +1,106 @@ +import { describe, it, expect, vi, beforeEach } from 'vitest' +import { renderHook, waitFor } from '@testing-library/react' +import { QueryClient, QueryClientProvider } from '@tanstack/react-query' +import type { ReactNode } from 'react' + +// Global setup in tests/setup-dom.ts auto-mocks '@/lib/ipc/invoke' so the rest +// of the renderer test suite can keep mocking through window.api. This file +// exercises the real invoke wrapper end-to-end against a stubbed Tauri core, +// so we unmock both module ids the wrapper may be registered under and then +// install a fake @tauri-apps/api/core that holds an in-memory KV store. +vi.unmock('@/lib/ipc/invoke') +vi.unmock('@/hooks/useSettings') + +vi.mock('@tauri-apps/api/core', () => { + const store = new Map() + + function readKey(args: unknown): string { + const payload = (args as { input?: { key?: string } } | undefined)?.input + return payload?.key ?? '' + } + + function readValue(args: unknown): string { + const payload = (args as { input?: { value?: string } } | undefined)?.input + return payload?.value ?? '' + } + + return { + invoke: vi.fn(async (cmd: string, args: unknown) => { + switch (cmd) { + case 'settings_set': + store.set(readKey(args), readValue(args)) + return undefined + case 'settings_get': + return store.get(readKey(args)) ?? null + case 'settings_list': + return Array.from(store.entries()).map(([key, value]) => ({ + key, + value, + modifiedAt: '2026-04-25T00:00:00.000Z' + })) + default: + throw new Error(`unmocked tauri invoke: ${cmd}`) + } + }) + } +}) + +import { useSetSetting, useSetting, useSettings } from '@/hooks/useSettings' + +function makeWrapper() { + const client = new QueryClient({ + defaultOptions: { queries: { retry: false }, mutations: { retry: false } } + }) + return function Wrapper({ children }: { children: ReactNode }) { + return {children} + } +} + +describe('useSettings', () => { + beforeEach(() => { + vi.clearAllMocks() + }) + + it('round-trips a value through the invoke boundary', async () => { + const wrapper = makeWrapper() + const { result } = renderHook( + () => { + const setSetting = useSetSetting() + const getSetting = useSetting('theme') + return { setSetting, getSetting } + }, + { wrapper } + ) + + result.current.setSetting.mutate({ key: 'theme', value: 'dark' }) + await waitFor(() => expect(result.current.setSetting.isSuccess).toBe(true)) + await waitFor(() => expect(result.current.getSetting.data).toBe('dark')) + }) + + it('reflects updates in the list query after mutation', async () => { + const wrapper = makeWrapper() + const { result } = renderHook( + () => { + const setSetting = useSetSetting() + const list = useSettings() + return { setSetting, list } + }, + { wrapper } + ) + + result.current.setSetting.mutate({ key: 'fontFamily', value: 'inter' }) + await waitFor(() => expect(result.current.setSetting.isSuccess).toBe(true)) + await waitFor(() => { + const items = result.current.list.data ?? [] + expect(items.some((s) => s.key === 'fontFamily' && s.value === 'inter')).toBe(true) + }) + }) + + it('returns null for an unset key', async () => { + const wrapper = makeWrapper() + const { result } = renderHook(() => useSetting('nonexistent'), { wrapper }) + + await waitFor(() => expect(result.current.isSuccess).toBe(true)) + expect(result.current.data).toBeNull() + }) +}) From 19e2cd46adf28cc21057aa72d38d7fd3ab777950 Mon Sep 17 00:00:00 2001 From: Kaan Karaca Date: Sun, 26 Apr 2026 01:21:42 +0300 Subject: [PATCH 21/25] m2(settings): migrate useGeneralSettings onto real settings_get/set KV path MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Codex adversarial review on Phase F flagged that the live onboarding flow still routed through the JS-side mock router because only the new generic useSettings hook was added — none of the existing domain-specific section hooks were migrated. Onboarding completion appeared to persist in dev because the mock module's state object survives between hook remounts, but nothing actually reached SQLite. This commit migrates the production caller (useGeneralSettings) onto the KV path while keeping the hook's external contract intact. - Read: invoke('settings_get', { input: { key: 'general' } }) returns the serialized JSON blob (or null on first run). parseStoredSettings merges any stored partial against DEFAULTS so forward-compat additions survive schema drift. - Write: settingsRef tracks the latest committed value; updateSettings derives `next = { ...current, ...patch }`, JSON.stringifies it, and pushes through invoke('settings_set', ...) before mutating local state. The optimistic update is skipped until the IPC succeeds. - Event subscription stays — settings-changed broadcasts still merge into local state for cross-window propagation when the eventing layer comes online in M3+. Regression coverage in use-general-settings.test.tsx (TDD red→green): 1. Asserts the hook only invokes settings_get / settings_set against the real Tauri core — never the legacy settings_get_general_settings or settings_set_general_settings mock routes. 2. onboardingCompleted survives unmount + remount through the real KV store (this was the exact case Codex flagged). 3. Multiple partial updates compose without losing prior fields (proves the JSON merge layer doesn't drop properties on second write). Test setup follows invoke.test.ts: vi.unmock('@/lib/ipc/invoke') bypasses the global setup-dom auto-mock so the assertion is on the real wrapper, and vi.mock('@tauri-apps/api/core') exposes a __resetStore knob that beforeEach uses to isolate the in-memory KV between cases. --- .../src/hooks/use-general-settings.test.tsx | 120 ++++++++++++++++++ .../src/hooks/use-general-settings.ts | 53 +++++--- 2 files changed, 158 insertions(+), 15 deletions(-) create mode 100644 apps/desktop-tauri/src/hooks/use-general-settings.test.tsx diff --git a/apps/desktop-tauri/src/hooks/use-general-settings.test.tsx b/apps/desktop-tauri/src/hooks/use-general-settings.test.tsx new file mode 100644 index 000000000..3818d8f07 --- /dev/null +++ b/apps/desktop-tauri/src/hooks/use-general-settings.test.tsx @@ -0,0 +1,120 @@ +import { describe, it, expect, vi, beforeEach } from 'vitest' +import { act, renderHook, waitFor } from '@testing-library/react' + +// The global setup in tests/setup-dom.ts auto-mocks '@/lib/ipc/invoke' so most +// hook tests can keep mocking through window.api. Phase F's regression test +// for the onboarding persistence path needs the *real* invoke wrapper so we +// can prove the fix actually routes through settings_get / settings_set +// against a stubbed Tauri core. +vi.unmock('@/lib/ipc/invoke') + +vi.mock('@tauri-apps/api/core', () => { + const store = new Map() + + function readKey(args: unknown): string { + const payload = (args as { input?: { key?: string } } | undefined)?.input + return payload?.key ?? '' + } + + function readValue(args: unknown): string { + const payload = (args as { input?: { value?: string } } | undefined)?.input + return payload?.value ?? '' + } + + return { + invoke: vi.fn(async (cmd: string, args: unknown) => { + switch (cmd) { + case 'settings_set': + store.set(readKey(args), readValue(args)) + return undefined + case 'settings_get': + return store.get(readKey(args)) ?? null + case 'settings_list': + return Array.from(store.entries()).map(([key, value]) => ({ + key, + value, + modifiedAt: '2026-04-26T00:00:00.000Z' + })) + default: + throw new Error(`unmocked tauri invoke: ${cmd}`) + } + }), + __resetStore: () => { + store.clear() + } + } +}) + +import * as TauriCore from '@tauri-apps/api/core' +import { useGeneralSettings } from './use-general-settings' + +const tauriCoreMock = TauriCore as unknown as { __resetStore?: () => void } +const tauriInvokeFn = TauriCore.invoke as unknown as { + mock: { calls: [string, unknown][] } +} + +function calledCommands(): string[] { + return tauriInvokeFn.mock.calls.map(([cmd]) => cmd) +} + +describe('useGeneralSettings (Phase F regression)', () => { + beforeEach(() => { + tauriCoreMock.__resetStore?.() + vi.clearAllMocks() + }) + + it('routes load+save through the real settings_get/settings_set commands', async () => { + const { result } = renderHook(() => useGeneralSettings()) + await waitFor(() => expect(result.current.isLoading).toBe(false)) + + await act(async () => { + await result.current.updateSettings({ onboardingCompleted: true }) + }) + + expect(calledCommands()).toContain('settings_get') + expect(calledCommands()).toContain('settings_set') + // No legacy domain-specific commands should be invoked through real Tauri. + expect(calledCommands()).not.toContain('settings_get_general_settings') + expect(calledCommands()).not.toContain('settings_set_general_settings') + }) + + it('persists onboardingCompleted through the real settings_get/set path', async () => { + const first = renderHook(() => useGeneralSettings()) + await waitFor(() => expect(first.result.current.isLoading).toBe(false)) + expect(first.result.current.settings.onboardingCompleted).toBe(false) + + await act(async () => { + const ok = await first.result.current.updateSettings({ onboardingCompleted: true }) + expect(ok).toBe(true) + }) + expect(first.result.current.settings.onboardingCompleted).toBe(true) + + first.unmount() + + const second = renderHook(() => useGeneralSettings()) + await waitFor(() => expect(second.result.current.isLoading).toBe(false)) + expect(second.result.current.settings.onboardingCompleted).toBe(true) + }) + + it('round-trips a partial appearance update without losing prior fields', async () => { + const first = renderHook(() => useGeneralSettings()) + await waitFor(() => expect(first.result.current.isLoading).toBe(false)) + + await act(async () => { + const ok = await first.result.current.updateSettings({ accentColor: '#abcdef' }) + expect(ok).toBe(true) + }) + await act(async () => { + const ok = await first.result.current.updateSettings({ fontFamily: 'inter' }) + expect(ok).toBe(true) + }) + + first.unmount() + + const second = renderHook(() => useGeneralSettings()) + await waitFor(() => expect(second.result.current.isLoading).toBe(false)) + expect(second.result.current.settings.accentColor).toBe('#abcdef') + expect(second.result.current.settings.fontFamily).toBe('inter') + expect(second.result.current.settings.theme).toBe('system') + }) +}) diff --git a/apps/desktop-tauri/src/hooks/use-general-settings.ts b/apps/desktop-tauri/src/hooks/use-general-settings.ts index 87eab54d1..5e22a6663 100644 --- a/apps/desktop-tauri/src/hooks/use-general-settings.ts +++ b/apps/desktop-tauri/src/hooks/use-general-settings.ts @@ -1,4 +1,4 @@ -import { useState, useEffect, useCallback } from 'react' +import { useState, useEffect, useCallback, useRef } from 'react' import { extractErrorMessage } from '@/lib/ipc-error' import { invoke } from '@/lib/ipc/invoke' import { subscribeEvent } from '@/lib/ipc/forwarder' @@ -9,6 +9,8 @@ interface SettingsChangedEvent { value: unknown } +const GENERAL_SETTINGS_KEY = 'general' + const DEFAULTS: GeneralSettingsDTO = { theme: 'system', fontSize: 'medium', @@ -28,17 +30,37 @@ interface UseGeneralSettingsReturn { updateSettings: (updates: Partial) => Promise } +function parseStoredSettings(raw: string | null): GeneralSettingsDTO { + if (!raw) return DEFAULTS + try { + const parsed = JSON.parse(raw) as Partial + return { ...DEFAULTS, ...parsed } + } catch { + return DEFAULTS + } +} + export function useGeneralSettings(): UseGeneralSettingsReturn { const [settings, setSettings] = useState(DEFAULTS) const [isLoading, setIsLoading] = useState(true) const [error, setError] = useState(null) + const settingsRef = useRef(DEFAULTS) + + useEffect(() => { + settingsRef.current = settings + }, [settings]) useEffect(() => { let mounted = true const load = async (): Promise => { try { - const result = await invoke('settings_get_general_settings') - if (mounted) setSettings(result) + const raw = await invoke('settings_get', { + input: { key: GENERAL_SETTINGS_KEY } + }) + if (!mounted) return + const merged = parseStoredSettings(raw) + setSettings(merged) + settingsRef.current = merged } catch (err) { if (mounted) setError(extractErrorMessage(err, 'Failed to load general settings')) } finally { @@ -53,25 +75,26 @@ export function useGeneralSettings(): UseGeneralSettingsReturn { useEffect(() => { return subscribeEvent('settings-changed', (event) => { - if (event.key === 'general') { - setSettings((prev) => ({ ...prev, ...(event.value as Partial) })) + if (event.key === GENERAL_SETTINGS_KEY) { + setSettings((prev) => { + const next = { ...prev, ...(event.value as Partial) } + settingsRef.current = next + return next + }) } }) }, []) const updateSettings = useCallback( async (updates: Partial): Promise => { + const next = { ...settingsRef.current, ...updates } try { - const result = await invoke<{ success: boolean; error?: string }>( - 'settings_set_general_settings', - updates as unknown as Record - ) - if (result.success) { - setSettings((prev) => ({ ...prev, ...updates })) - return true - } - setError(result.error ?? 'Update failed') - return false + await invoke('settings_set', { + input: { key: GENERAL_SETTINGS_KEY, value: JSON.stringify(next) } + }) + setSettings(next) + settingsRef.current = next + return true } catch (err) { setError(extractErrorMessage(err, 'Failed to update general settings')) return false From 0da81aeeb8e7c0ed7c597213799683097003e825 Mon Sep 17 00:00:00 2001 From: Kaan Karaca Date: Sun, 26 Apr 2026 01:25:58 +0300 Subject: [PATCH 22/25] m2(devx): add MEMRY_DEVICE=A/B dev scripts --- apps/desktop-tauri/package.json | 2 ++ 1 file changed, 2 insertions(+) diff --git a/apps/desktop-tauri/package.json b/apps/desktop-tauri/package.json index 344a06530..622d658df 100644 --- a/apps/desktop-tauri/package.json +++ b/apps/desktop-tauri/package.json @@ -7,6 +7,8 @@ "type": "module", "scripts": { "dev": "tauri dev", + "dev:a": "MEMRY_DEVICE=A tauri dev", + "dev:b": "MEMRY_DEVICE=B tauri dev", "build": "tauri build", "preview": "vite preview", "lint": "pnpm exec eslint --cache .", From fa249b2752f0e11692ed884dca6f78d03c9f3ab1 Mon Sep 17 00:00:00 2001 From: Kaan Karaca Date: Sun, 26 Apr 2026 01:49:21 +0300 Subject: [PATCH 23/25] m2(devx): add dev scripts and parity audit MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit - scripts/dev-reset.sh, new-migration.ts, schema-diff.ts (DB tooling) - scripts/command-parity-audit.ts (renderer↔mock↔Rust classification ledger) - Replace electron-log/renderer logger with a Tauri-safe console wrapper - Harden port:audit to flag electron-log + bare 'electron' imports and track @memry/* residue (114 in production code, informational ledger) - Align updater mocks with use-app-updater hook (get_state / check_for_updates / download_update / quit_and_install) using the contract's AppUpdateState shape; legacy updater_check / _download / _install names removed - Add notify_flush_done as a real no-op Rust command so the renderer's flush-on-quit hook stops 404-ing through the mock router; full lifecycle coordinator deferred to M8.0 - Register db:reset, db:new-migration, db:schema-diff, command:parity scripts in package.json - Update setup-dom.ts mock target from electron-log/renderer to @/lib/logger so logger spies still work in tests --- apps/desktop-tauri/package.json | 8 +- .../scripts/command-parity-audit.test.ts | 130 +++++ .../scripts/command-parity-audit.ts | 540 ++++++++++++++++++ apps/desktop-tauri/scripts/dev-reset.sh | 23 + apps/desktop-tauri/scripts/new-migration.ts | 60 ++ apps/desktop-tauri/scripts/port-audit.test.ts | 93 ++- apps/desktop-tauri/scripts/port-audit.ts | 31 +- apps/desktop-tauri/scripts/schema-diff.ts | 98 ++++ .../src-tauri/src/bin/generate_bindings.rs | 1 + .../src-tauri/src/commands/lifecycle.rs | 15 + .../src-tauri/src/commands/mod.rs | 3 + apps/desktop-tauri/src-tauri/src/lib.rs | 1 + apps/desktop-tauri/src/generated/bindings.ts | 10 + apps/desktop-tauri/src/lib/ipc/invoke.ts | 3 +- .../src/lib/ipc/mocks/updater.test.ts | 81 +-- .../src/lib/ipc/mocks/updater.ts | 67 ++- apps/desktop-tauri/src/lib/logger.ts | 57 +- .../src/lib/save-registry.test.ts | 4 - apps/desktop-tauri/tests/setup-dom.ts | 15 +- pnpm-lock.yaml | 6 + 20 files changed, 1151 insertions(+), 95 deletions(-) create mode 100644 apps/desktop-tauri/scripts/command-parity-audit.test.ts create mode 100644 apps/desktop-tauri/scripts/command-parity-audit.ts create mode 100755 apps/desktop-tauri/scripts/dev-reset.sh create mode 100644 apps/desktop-tauri/scripts/new-migration.ts create mode 100644 apps/desktop-tauri/scripts/schema-diff.ts create mode 100644 apps/desktop-tauri/src-tauri/src/commands/lifecycle.rs diff --git a/apps/desktop-tauri/package.json b/apps/desktop-tauri/package.json index 622d658df..9f4192ccc 100644 --- a/apps/desktop-tauri/package.json +++ b/apps/desktop-tauri/package.json @@ -24,7 +24,11 @@ "bindings:generate": "tsx scripts/generate-bindings.ts", "bindings:check": "tsx scripts/check-bindings.ts", "capability:check": "tsx scripts/capability-sanity-check.ts", - "port:audit": "tsx scripts/port-audit.ts" + "port:audit": "tsx scripts/port-audit.ts", + "command:parity": "tsx scripts/command-parity-audit.ts", + "db:reset": "bash scripts/dev-reset.sh", + "db:new-migration": "tsx scripts/new-migration.ts", + "db:schema-diff": "tsx scripts/schema-diff.ts" }, "dependencies": { "@ai-sdk/anthropic": "^3.0.58", @@ -149,6 +153,7 @@ "@testing-library/jest-dom": "^6.9.1", "@testing-library/react": "^16.3.2", "@testing-library/user-event": "^14.6.1", + "@types/better-sqlite3": "^7.6.13", "@types/node": "^25.2.2", "@types/react": "^19.2.13", "@types/react-dom": "^19.2.3", @@ -156,6 +161,7 @@ "@vitest/coverage-v8": "^4.0.18", "@vitest/ui": "^4.0.18", "autoprefixer": "^10.4.24", + "better-sqlite3": "^12.6.2", "eslint": "^9.39.2", "eslint-plugin-react": "^7.37.5", "eslint-plugin-react-hooks": "^7.0.1", diff --git a/apps/desktop-tauri/scripts/command-parity-audit.test.ts b/apps/desktop-tauri/scripts/command-parity-audit.test.ts new file mode 100644 index 000000000..c362de7dd --- /dev/null +++ b/apps/desktop-tauri/scripts/command-parity-audit.test.ts @@ -0,0 +1,130 @@ +import { describe, expect, it } from 'vitest' + +import { + extractBindingsCommands, + extractElectronChannels, + extractForwarderDomains, + extractGenerateHandlerCommands, + extractInvokeLiterals, + extractMockRouteKeys, +} from './command-parity-audit' + +describe('extractInvokeLiterals', () => { + it('returns the literal string passed to invoke()', () => { + // #given a renderer file + const src = "await invoke('settings_get', { key: 'a' })" + + // #when scanning for literals + const found = extractInvokeLiterals(src) + + // #then the command name is captured + expect(found).toEqual(['settings_get']) + }) + + it('captures generic-typed invoke(name)', () => { + // #given a renderer file using the typed invoke + const src = "const x = await invoke('notes_list', { folder })" + + // #when scanning for literals + const found = extractInvokeLiterals(src) + + // #then the command name is captured + expect(found).toEqual(['notes_list']) + }) + + it('ignores non-string-literal invoke calls', () => { + // #given dynamic invoke usage + const src = 'await invoke(name, args)' + + // #when scanning for literals + const found = extractInvokeLiterals(src) + + // #then dynamic calls do not produce a literal + expect(found).toEqual([]) + }) +}) + +describe('extractForwarderDomains', () => { + it('captures the domain prefix from createInvokeForwarder', () => { + // #given a service module wires a forwarder + const src = "createInvokeForwarder('notes')" + + // #when scanning for forwarder domains + const found = extractForwarderDomains(src) + + // #then the domain prefix is captured + expect(found).toEqual(['notes']) + }) +}) + +describe('extractMockRouteKeys', () => { + it('returns top-level route keys from a Routes object literal', () => { + // #given a mock module with two top-level routes and one nested object + const src = [ + "export const updaterRoutes: MockRouteMap = {", + ' updater_get_state: async () => state,', + ' updater_check_for_updates: async () => state,', + ' meta: { unrelated: 1 }', + '}', + ].join('\n') + + // #when extracting keys + const found = extractMockRouteKeys(src) + + // #then only the top-level keys with the route shape come back + expect(found.sort()).toEqual(['meta', 'updater_check_for_updates', 'updater_get_state']) + }) +}) + +describe('extractGenerateHandlerCommands', () => { + it('extracts the last segment of every entry in generate_handler!', () => { + // #given a Tauri lib.rs handler list + const src = [ + 'tauri::generate_handler![', + ' commands::settings::settings_get,', + ' commands::settings::settings_set,', + ' commands::lifecycle::notify_flush_done,', + ']', + ].join('\n') + + // #when parsing the macro body + const found = extractGenerateHandlerCommands(src) + + // #then we get the bare command names + expect(found.sort()).toEqual(['notify_flush_done', 'settings_get', 'settings_set']) + }) +}) + +describe('extractBindingsCommands', () => { + it('captures __TAURI_INVOKE("name") calls from the generated bindings', () => { + // #given a specta-generated bindings snippet + const src = ` + settingsGet: () => __TAURI_INVOKE("settings_get", { input }), + notifyFlushDone: () => __TAURI_INVOKE("notify_flush_done"), + ` + + // #when parsing it + const found = extractBindingsCommands(src) + + // #then both names are reported + expect(found.sort()).toEqual(['notify_flush_done', 'settings_get']) + }) +}) + +describe('extractElectronChannels', () => { + it('captures kebab-style "domain:method" entries from generated-ipc-invoke-map.ts', () => { + // #given a snippet of the Electron generated map + const src = [ + 'export interface MainIpcInvokeHandlers {', + ' "auth:request-otp": (...args: []) => Awaited', + ' "calendar:list-events": (...args: []) => Awaited', + '}', + ].join('\n') + + // #when extracting channels + const found = extractElectronChannels(src) + + // #then both channels surface + expect(found.sort()).toEqual(['auth:request-otp', 'calendar:list-events']) + }) +}) diff --git a/apps/desktop-tauri/scripts/command-parity-audit.ts b/apps/desktop-tauri/scripts/command-parity-audit.ts new file mode 100644 index 000000000..d8841d049 --- /dev/null +++ b/apps/desktop-tauri/scripts/command-parity-audit.ts @@ -0,0 +1,540 @@ +#!/usr/bin/env tsx +/** + * Command parity audit — classifies every Tauri renderer command and reports + * gaps relative to Electron's IPC surface. + * + * Inputs scanned: + * - Electron contract surfaces: + * packages/contracts/src/** (channel constant unions) + * apps/desktop/src/preload/** (preload api shape — not enumerated keys) + * apps/desktop/src/main/ipc/generated-ipc-invoke-map.ts (every Electron channel) + * - Tauri renderer: + * apps/desktop-tauri/src/** literal `invoke('xxx', ...)` calls + * apps/desktop-tauri/src/** `createInvokeForwarder('domain')` use + * - Tauri mocks: + * apps/desktop-tauri/src/lib/ipc/mocks/.ts route maps + * - Real Rust: + * apps/desktop-tauri/src-tauri/src/commands/** (#[tauri::command] fns) + * apps/desktop-tauri/src-tauri/src/lib.rs (generate_handler![]) + * apps/desktop-tauri/src/generated/bindings.ts (specta export) + * + * Classification per Tauri-renderer command: + * - real — Rust handler + generated binding (production path) + * - mocked — served by mock router until Rust lands + * - renderer-only — invoked by renderer but no mock + no real (FAIL) + * - retired — known deferred name with no live call site + * - deferred: — explicit deferral entry in DEFERRED ledger + * + * M2 invariants: + * - settings_get / settings_set / settings_list MUST be `real`. + * - notify_flush_done MUST be `real` or explicitly `deferred:M8.0`. + * - Updater renderer commands (updater_get_state, updater_check_for_updates, + * updater_download_update, updater_quit_and_install) MUST have matching + * mock routes — old `updater_check`/`updater_download`/`updater_install` + * names are forbidden unless listed in DEFERRED. + * - No literal renderer invoke can be unclassified. + */ +import { readFileSync, readdirSync, statSync, globSync } from 'node:fs' +import { dirname, resolve } from 'node:path' +import { fileURLToPath } from 'node:url' + +const __dirname = dirname(fileURLToPath(import.meta.url)) +const TAURI_ROOT = resolve(__dirname, '..') +const REPO_ROOT = resolve(TAURI_ROOT, '../..') +const RENDERER_SRC = resolve(TAURI_ROOT, 'src') +const MOCKS_DIR = resolve(RENDERER_SRC, 'lib/ipc/mocks') +const RUST_SRC = resolve(TAURI_ROOT, 'src-tauri/src') +const ELECTRON_INVOKE_MAP = resolve( + REPO_ROOT, + 'apps/desktop/src/main/ipc/generated-ipc-invoke-map.ts', +) +const BINDINGS_FILE = resolve(RENDERER_SRC, 'generated/bindings.ts') + +/** + * M2 deferral ledger — every renderer literal-invoke that has no mock route + * yet AND no Rust handler. Tagging each entry with a milestone keeps the + * carry-forward bookkeeping honest: as later milestones land mocks/Rust + * handlers, entries here graduate out, and the audit catches new renderer + * calls that lack any classification. + * + * Format: command → milestone string (informational; rendered in report). + */ +const DEFERRED: Record = { + // Logging forwarding lives behind a thin Rust shim in M8.0 lifecycle work. + logging_forward: 'M8.0', + + // M3 — vault FS + per-domain CRUD that wasn't covered by M1 mocks. + bookmarks_toggle: 'M3', + bookmarks_is_bookmarked: 'M3', + bookmarks_reorder: 'M3', + inbox_bulk_snooze: 'M3', + inbox_bulk_tag: 'M3', + inbox_preview_link: 'M3', + inbox_track_suggestion: 'M3', + folder_view_delete_view: 'M3', + folder_view_folder_exists: 'M3', + folder_view_get_folder_suggestions: 'M3', + folder_view_get_views: 'M3', + folder_view_list_with_properties: 'M3', + folder_view_set_config: 'M3', + folder_view_set_view: 'M3', + graph_get_data: 'M3', + graph_get_local: 'M3', + notes_create_folder: 'M3', + notes_open_external: 'M3', + notes_reveal_in_finder: 'M3', + reminders_bulk_dismiss: 'M3', + reminders_count_pending: 'M3', + reminders_dismiss: 'M3', + reminders_get_due: 'M3', + reminders_get_for_target: 'M3', + reminders_get_upcoming: 'M3', + search_add_reason: 'M3', + search_clear_reasons: 'M3', + search_get_all_tags: 'M3', + search_get_reasons: 'M3', + search_get_stats: 'M3', + search_quick: 'M3', + search_rebuild_index: 'M3', + tags_delete_tag: 'M3', + tags_merge_tag: 'M3', + tags_rename_tag: 'M3', + tags_update_tag_color: 'M3', + templates_duplicate: 'M3', + + // M3 — sub-domain settings keys carry forward to per-section settings work. + settings_download_voice_model: 'M3', + settings_get_ai_model_status: 'M3', + settings_get_calendar_google_settings: 'M3', + settings_get_editor_settings: 'M3', + settings_get_graph_settings: 'M3', + settings_get_keyboard_settings: 'M3', + settings_get_note_editor_settings: 'M3', + settings_get_task_settings: 'M3', + settings_get_voice_model_status: 'M3', + settings_get_voice_recording_readiness: 'M3', + settings_get_voice_transcription_open_ai_key_status: 'M3', + settings_get_voice_transcription_settings: 'M3', + settings_load_ai_model: 'M3', + settings_register_global_capture: 'M3', + settings_reindex_embeddings: 'M3', + settings_reset_keyboard_settings: 'M3', + settings_set_calendar_google_settings: 'M3', + settings_set_editor_settings: 'M3', + settings_set_graph_settings: 'M3', + settings_set_keyboard_settings: 'M3', + settings_set_note_editor_settings: 'M3', + settings_set_task_settings: 'M3', + settings_set_voice_transcription_open_ai_key: 'M3', + settings_set_voice_transcription_settings: 'M3', + + // M4 — auth + crypto + linking lifecycle. + account_get_recovery_key: 'M4', + crypto_rotate_keys: 'M4', + sync_auth_logout: 'M4', + sync_linking_approve_linking: 'M4', + sync_linking_complete_linking_qr: 'M4', + sync_linking_generate_linking_qr: 'M4', + sync_linking_get_linking_sas: 'M4', + sync_linking_link_via_qr: 'M4', + sync_linking_link_via_recovery: 'M4', + sync_setup_get_recovery_phrase: 'M4', + + // M5 — CRDT engine. + sync_crdt_apply_update: 'M5', + sync_crdt_close_doc: 'M5', + sync_crdt_open_doc: 'M5', + sync_crdt_sync_step1: 'M5', + sync_crdt_sync_step2: 'M5', + + // M6 — sync ops orchestration. + sync_ops_get_history: 'M6', + sync_ops_get_storage_breakdown: 'M6', + sync_ops_pause: 'M6', + sync_ops_resume: 'M6', + sync_ops_trigger_sync: 'M6', + + // M8.0 — lifecycle / native quick-capture window. + quick_capture_close: 'M8.0', + quick_capture_get_clipboard: 'M8.0', + quick_capture_open_settings: 'M8.0', + quick_capture_resize: 'M8.0', + show_context_menu: 'M8.0', +} + +/** Forbid these legacy renderer/mock names — Phase G rename enforcement. */ +const FORBIDDEN_NAMES = new Set(['updater_check', 'updater_download', 'updater_install']) + +/** M2 hard requirements: these MUST resolve to `real`. */ +const REQUIRED_REAL = new Set(['settings_get', 'settings_set', 'settings_list']) + +/** M2 shell-neutral wrappers: real or deferred-with-classification. */ +const SHELL_NEUTRAL_REAL_OR_DEFERRED = new Set(['notify_flush_done']) + +/** M2 updater renderer surface — every name here MUST be present as a mock. */ +const REQUIRED_UPDATER_MOCKS = new Set([ + 'updater_get_state', + 'updater_check_for_updates', + 'updater_download_update', + 'updater_quit_and_install', +]) + +type Classification = + | { kind: 'real' } + | { kind: 'mocked' } + | { kind: 'deferred'; milestone: string } + | { kind: 'renderer-only' } + | { kind: 'retired' } + +export interface AuditResult { + rendererCalls: Set + mockedCommands: Set + realCommands: Set + bindingsCommands: Set + forwarderDomains: Set + electronChannels: Set + classifications: Map + errors: string[] + warnings: string[] +} + +function readUtf8(path: string): string { + return readFileSync(path, 'utf8') +} + +function listFilesRec(dir: string, exts: string[]): string[] { + const out: string[] = [] + const stack: string[] = [dir] + while (stack.length) { + const cur = stack.pop()! + let entries: string[] + try { + entries = readdirSync(cur) + } catch { + continue + } + for (const e of entries) { + const full = resolve(cur, e) + let st + try { + st = statSync(full) + } catch { + continue + } + if (st.isDirectory()) { + if (e === 'node_modules') continue + stack.push(full) + continue + } + if (exts.some((x) => full.endsWith(x))) out.push(full) + } + } + return out +} + +function isProductionFile(path: string): boolean { + return !/\.test\.(ts|tsx)$/.test(path) +} + +/** Extract every literal-string `invoke('cmd', ...)` argument. */ +export function extractInvokeLiterals(source: string): string[] { + const out = new Set() + const re = /\binvoke\s*(?:<[^>]+>)?\s*\(\s*['"]([a-z][a-z0-9_]+)['"]/g + for (const m of source.matchAll(re)) out.add(m[1]) + return [...out] +} + +/** Extract `createInvokeForwarder('domain')` domain prefixes. */ +export function extractForwarderDomains(source: string): string[] { + const out = new Set() + const re = /createInvokeForwarder\s*<[^>]+>\s*\(\s*['"]([a-z][a-z0-9_]+)['"]/g + for (const m of source.matchAll(re)) out.add(m[1]) + return [...out] +} + +/** + * Pull route keys from a mock module. Looks for the `Routes: + * MockRouteMap = { ... }` literal and extracts identifier-like keys at the top + * level. Conservative: only keys with `name: async`, `name: (` or `name,` + * forms count. + */ +export function extractMockRouteKeys(source: string): string[] { + const out = new Set() + const objMatch = source.match(/Routes\s*:\s*MockRouteMap\s*=\s*\{([\s\S]*?)\n\}/) + if (!objMatch) return [] + const body = objMatch[1] + let depth = 0 + // Strip nested braces so only top-level keys leak through. + const flat: string[] = [] + for (const ch of body) { + if (ch === '{') depth++ + else if (ch === '}') depth-- + if (depth === 0) flat.push(ch) + } + const cleaned = flat.join('') + const keyRe = /(?:^|[\n,])\s*([a-z][a-z0-9_]+)\s*:/g + for (const m of cleaned.matchAll(keyRe)) out.add(m[1]) + return [...out] +} + +/** Parse `tauri::generate_handler![path::name, ...]` into command names. */ +export function extractGenerateHandlerCommands(source: string): string[] { + const out = new Set() + const macroMatch = source.match(/generate_handler!\s*\[([\s\S]*?)\]/) + if (!macroMatch) return [] + const body = macroMatch[1] + for (const tok of body.split(',')) { + const trimmed = tok.trim().replace(/[\s;]+$/, '') + if (!trimmed) continue + const last = trimmed.split('::').pop()! + if (/^[a-z][a-z0-9_]+$/.test(last)) out.add(last) + } + return [...out] +} + +/** Parse `__TAURI_INVOKE("name"` from the specta-generated bindings file. */ +export function extractBindingsCommands(source: string): string[] { + const out = new Set() + const re = /__TAURI_INVOKE\(\s*"([a-z][a-z0-9_]+)"/g + for (const m of source.matchAll(re)) out.add(m[1]) + return [...out] +} + +/** Pull Electron channel names (kebab-style) from generated-ipc-invoke-map.ts. */ +export function extractElectronChannels(source: string): string[] { + const out = new Set() + const re = /^\s*"([a-z][a-z0-9-]*:[a-z0-9-]+)"\s*:/gm + for (const m of source.matchAll(re)) out.add(m[1]) + return [...out] +} + +function gatherRendererSurfaces(): { + invokes: Set + forwarders: Set +} { + const files = listFilesRec(RENDERER_SRC, ['.ts', '.tsx']).filter(isProductionFile) + const invokes = new Set() + const forwarders = new Set() + for (const f of files) { + const src = readUtf8(f) + for (const c of extractInvokeLiterals(src)) invokes.add(c) + for (const d of extractForwarderDomains(src)) forwarders.add(d) + } + return { invokes, forwarders } +} + +function gatherMockCommands(): Set { + const out = new Set() + const files = readdirSync(MOCKS_DIR) + .filter((f) => f.endsWith('.ts') && !/\.test\.ts$/.test(f) && f !== 'types.ts' && f !== 'index.ts') + .map((f) => resolve(MOCKS_DIR, f)) + for (const f of files) { + const src = readUtf8(f) + for (const k of extractMockRouteKeys(src)) out.add(k) + } + return out +} + +function gatherRealCommands(): { real: Set; bindings: Set } { + const real = new Set() + const libRsPath = resolve(RUST_SRC, 'lib.rs') + if (statSync(libRsPath).isFile()) { + for (const c of extractGenerateHandlerCommands(readUtf8(libRsPath))) real.add(c) + } + const bindings = new Set() + if (globSync(BINDINGS_FILE).length > 0) { + for (const c of extractBindingsCommands(readUtf8(BINDINGS_FILE))) bindings.add(c) + } + return { real, bindings } +} + +function classify(input: { + rendererCalls: Set + mocked: Set + real: Set +}): Map { + const out = new Map() + for (const cmd of input.rendererCalls) { + if (input.real.has(cmd)) { + out.set(cmd, { kind: 'real' }) + continue + } + if (DEFERRED[cmd]) { + out.set(cmd, { kind: 'deferred', milestone: DEFERRED[cmd] }) + continue + } + if (input.mocked.has(cmd)) { + out.set(cmd, { kind: 'mocked' }) + continue + } + out.set(cmd, { kind: 'renderer-only' }) + } + // Mock-only entries (no renderer call site) — useful for catching dead routes + // but not failing. + for (const cmd of input.mocked) { + if (out.has(cmd)) continue + out.set(cmd, { kind: 'mocked' }) + } + // Deferred entries that may not be called by renderer yet (e.g. logging_forward). + for (const cmd of Object.keys(DEFERRED)) { + if (out.has(cmd)) continue + out.set(cmd, { kind: 'deferred', milestone: DEFERRED[cmd] }) + } + return out +} + +export function runAudit(): AuditResult { + const { invokes, forwarders } = gatherRendererSurfaces() + const mocked = gatherMockCommands() + const { real, bindings } = gatherRealCommands() + const electron = (() => { + try { + return new Set(extractElectronChannels(readUtf8(ELECTRON_INVOKE_MAP))) + } catch { + return new Set() + } + })() + + const classifications = classify({ rendererCalls: invokes, mocked, real }) + const errors: string[] = [] + const warnings: string[] = [] + + for (const cmd of REQUIRED_REAL) { + const c = classifications.get(cmd) + if (!c || c.kind !== 'real') { + errors.push(`required-real "${cmd}" is ${c?.kind ?? 'absent'} (M2 invariant)`) + } + if (!bindings.has(cmd)) { + errors.push(`required-real "${cmd}" missing from generated bindings`) + } + } + + for (const cmd of SHELL_NEUTRAL_REAL_OR_DEFERRED) { + const c = classifications.get(cmd) + if (!c) { + errors.push(`shell-neutral wrapper "${cmd}" not found in any surface`) + continue + } + if (c.kind === 'real') continue + if (c.kind === 'deferred') continue + errors.push( + `shell-neutral wrapper "${cmd}" must be real or deferred, got ${c.kind}`, + ) + } + + for (const cmd of REQUIRED_UPDATER_MOCKS) { + if (!mocked.has(cmd) && !real.has(cmd)) { + errors.push(`updater renderer surface "${cmd}" missing from mocks and real handlers`) + } + } + + for (const cmd of FORBIDDEN_NAMES) { + if (mocked.has(cmd)) { + errors.push(`forbidden legacy mock route "${cmd}" still registered`) + } + if (invokes.has(cmd)) { + errors.push(`forbidden legacy command "${cmd}" still invoked from renderer`) + } + } + + for (const [cmd, c] of classifications) { + if (c.kind === 'renderer-only') { + errors.push(`unclassified renderer command "${cmd}" — add a mock or deferral entry`) + } + } + + // Forwarder domains MUST have a corresponding mock module (the forwarder + // proxies any method on the domain to invoke('domain_method'), so without a + // mock module those calls 404 at runtime). + for (const domain of forwarders) { + const mockFile = resolve(MOCKS_DIR, `${domain.replace(/_/g, '-')}.ts`) + const altFile = resolve(MOCKS_DIR, `${domain}.ts`) + if (!fileExists(mockFile) && !fileExists(altFile)) { + warnings.push( + `forwarder domain "${domain}" has no mocks/${domain}.ts module — runtime 404 risk`, + ) + } + } + + // Mock routes that don't correspond to any Tauri renderer call site or + // Rust command — informational, not failure. + for (const cmd of mocked) { + if (real.has(cmd)) continue + if (invokes.has(cmd)) continue + // A mock keyed by a forwarder method call name like `tasks_list` is + // exercised through the forwarder proxy; presence of the matching + // forwarder domain is enough to consider it live. + const domainPrefix = [...forwarders].find((d) => cmd.startsWith(`${d}_`) || cmd === d) + if (domainPrefix) continue + warnings.push(`mock route "${cmd}" has no renderer call site or forwarder domain`) + } + + return { + rendererCalls: invokes, + mockedCommands: mocked, + realCommands: real, + bindingsCommands: bindings, + forwarderDomains: forwarders, + electronChannels: electron, + classifications, + errors, + warnings, + } +} + +function fileExists(path: string): boolean { + try { + return statSync(path).isFile() + } catch { + return false + } +} + +function summarize(result: AuditResult): void { + const counts = { real: 0, mocked: 0, deferred: 0, 'renderer-only': 0, retired: 0 } + for (const c of result.classifications.values()) { + counts[c.kind] = (counts[c.kind] ?? 0) + 1 + } + + console.log('Command parity audit') + console.log('--------------------') + console.log(`Renderer literal invokes : ${result.rendererCalls.size}`) + console.log(`Forwarder domains : ${result.forwarderDomains.size}`) + console.log(`Mock routes : ${result.mockedCommands.size}`) + console.log(`Rust real commands : ${result.realCommands.size}`) + console.log(`Generated bindings : ${result.bindingsCommands.size}`) + console.log(`Electron channels (ref) : ${result.electronChannels.size}`) + console.log('') + console.log( + `Classifications: real=${counts.real} mocked=${counts.mocked} ` + + `deferred=${counts.deferred} renderer-only=${counts['renderer-only']} ` + + `retired=${counts.retired}`, + ) + + if (result.warnings.length) { + console.log('\nWarnings:') + for (const w of result.warnings) console.log(` • ${w}`) + } + if (result.errors.length) { + console.log('\nErrors:') + for (const e of result.errors) console.log(` ✘ ${e}`) + } +} + +function main(): void { + const result = runAudit() + summarize(result) + if (result.errors.length > 0) { + console.log(`\nFAIL: ${result.errors.length} error(s) — see above.`) + process.exit(1) + } + console.log('\nOK: command parity audit clean.') +} + +const invokedAsScript = process.argv[1] + ? resolve(process.argv[1]) === fileURLToPath(import.meta.url) + : false + +if (invokedAsScript) { + main() +} diff --git a/apps/desktop-tauri/scripts/dev-reset.sh b/apps/desktop-tauri/scripts/dev-reset.sh new file mode 100755 index 000000000..0e49c79b8 --- /dev/null +++ b/apps/desktop-tauri/scripts/dev-reset.sh @@ -0,0 +1,23 @@ +#!/usr/bin/env bash +set -euo pipefail + +# Wipe memry app data for the selected device profile (or all profiles). +# +# Usage: +# ./scripts/dev-reset.sh # resets default profile +# ./scripts/dev-reset.sh A # resets profile A +# ./scripts/dev-reset.sh --all # resets every memry-* profile + +BASE="$HOME/Library/Application Support/com.memry.memry" + +if [[ "${1:-}" == "--all" ]]; then + echo "Wiping $BASE" + rm -rf "$BASE" + exit 0 +fi + +DEVICE="${1:-default}" +TARGET="$BASE/memry-$DEVICE" +echo "Wiping $TARGET" +rm -rf "$TARGET" +echo "Done. Next app launch will re-apply migrations." diff --git a/apps/desktop-tauri/scripts/new-migration.ts b/apps/desktop-tauri/scripts/new-migration.ts new file mode 100644 index 000000000..ca1bd227b --- /dev/null +++ b/apps/desktop-tauri/scripts/new-migration.ts @@ -0,0 +1,60 @@ +#!/usr/bin/env tsx +/** + * Create a new migration file with the next sequential number. + * + * Usage: + * pnpm db:new-migration "add_widgets_table" + * + * NOTE: After creating the file, you must manually add an entry to the + * EMBEDDED list in `src-tauri/src/db/migrations.rs` — this script prints + * the exact line to insert. + */ +import { existsSync, readdirSync, writeFileSync } from 'node:fs' +import { dirname, resolve } from 'node:path' +import { fileURLToPath } from 'node:url' + +const __dirname = dirname(fileURLToPath(import.meta.url)) +const MIGRATIONS_DIR = resolve(__dirname, '../src-tauri/migrations') +const MANIFEST_PATH = resolve(__dirname, '../src-tauri/src/db/migrations.rs') + +function nextNumber(): string { + const files = readdirSync(MIGRATIONS_DIR).filter((f) => f.endsWith('.sql')) + if (files.length === 0) return '0001' + const max = Math.max(...files.map((f) => Number(f.slice(0, 4)))) + return String(max + 1).padStart(4, '0') +} + +function main() { + const name = process.argv[2] + if (!name) { + console.error('Usage: pnpm db:new-migration ""') + process.exit(1) + } + if (!/^[a-z0-9_]+$/.test(name)) { + console.error('Name must be snake_case, lowercase, digits or underscores only.') + process.exit(1) + } + + const num = nextNumber() + const filename = `${num}_${name}.sql` + const target = resolve(MIGRATIONS_DIR, filename) + + if (existsSync(target)) { + console.error(`${filename} already exists.`) + process.exit(1) + } + + writeFileSync( + target, + `-- ${filename}\n-- TODO: describe what this migration changes\n\n`, + ) + + console.log(`Created ${filename}`) + console.log( + `\nNext: add an entry to EMBEDDED in:\n ${MANIFEST_PATH}\n\n` + + ` ("${filename}", include_str!("../../migrations/${filename}")),\n\n` + + `Also bump the array length in the migration_manifest module.`, + ) +} + +main() diff --git a/apps/desktop-tauri/scripts/port-audit.test.ts b/apps/desktop-tauri/scripts/port-audit.test.ts index bb5269f82..6c84d466c 100644 --- a/apps/desktop-tauri/scripts/port-audit.test.ts +++ b/apps/desktop-tauri/scripts/port-audit.test.ts @@ -1,5 +1,5 @@ import { describe, it, expect } from 'vitest' -import { scanContent, isTestFile } from './port-audit' +import { scanContent, isTestFile, countMemryRefs } from './port-audit' describe('scanContent', () => { it('reports 1 window.api hit with correct line number', () => { @@ -20,17 +20,16 @@ describe('scanContent', () => { ]) }) - it('reports 1 ipcRenderer hit', () => { + it('reports both ipcRenderer and electron-import hits on the same import line', () => { // #given const content = "import { ipcRenderer } from 'electron'" // #when const hits = scanContent(content, 'fake.ts') - // #then - expect(hits).toHaveLength(1) - expect(hits[0].kind).toBe('ipcRenderer') - expect(hits[0].line).toBe(1) + // #then both Electron-era patterns surface so neither slips through audit + expect(hits).toHaveLength(2) + expect(hits.map((h) => h.kind).sort()).toEqual(['electron-import', 'ipcRenderer']) }) it('reports 1 electron-toolkit hit', () => { @@ -99,15 +98,16 @@ describe('scanContent', () => { // #when const hits = scanContent(content, 'multi.ts') - // #then - expect(hits).toHaveLength(4) + // #then line 1 matches ipcRenderer + electron-import simultaneously + expect(hits).toHaveLength(5) expect(hits.map((h) => h.kind)).toEqual([ 'ipcRenderer', + 'electron-import', 'electron-toolkit', 'window.api', 'window.electron' ]) - expect(hits.map((h) => h.line)).toEqual([1, 2, 3, 4]) + expect(hits.map((h) => h.line)).toEqual([1, 1, 2, 3, 4]) }) it('ignores ipcRenderer substring that is not a whole word', () => { @@ -120,6 +120,81 @@ describe('scanContent', () => { // #then expect(hits.filter((h) => h.kind === 'ipcRenderer')).toEqual([]) }) + + it('reports 1 electron-log hit on bare import', () => { + // #given + const content = "import log from 'electron-log/renderer'" + + // #when + const hits = scanContent(content, 'fake.ts') + + // #then + expect(hits).toHaveLength(1) + expect(hits[0].kind).toBe('electron-log') + }) + + it('reports 1 electron-log hit on plain electron-log import', () => { + // #given + const content = "import log from 'electron-log'" + + // #when + const hits = scanContent(content, 'fake.ts') + + // #then + expect(hits).toHaveLength(1) + expect(hits[0].kind).toBe('electron-log') + }) + + it('reports 1 electron-import hit for `from "electron"`', () => { + // #given + const content = "import { app } from 'electron'" + + // #when + const hits = scanContent(content, 'fake.ts') + + // #then + expect(hits).toHaveLength(1) + expect(hits[0].kind).toBe('electron-import') + }) + + it('does not flag the Tauri-safe logger module name', () => { + // #given + const content = "import { createLogger } from '@/lib/logger'" + + // #when + const hits = scanContent(content, 'fake.ts') + + // #then + expect(hits).toEqual([]) + }) +}) + +describe('countMemryRefs', () => { + it('counts every @memry/ occurrence', () => { + // #given + const content = [ + "import type { Foo } from '@memry/contracts/notes-api'", + "import { Bar } from '@memry/shared/utils'", + 'const x = 1' + ].join('\n') + + // #when + const total = countMemryRefs(content) + + // #then + expect(total).toBe(2) + }) + + it('returns 0 for clean Tauri code', () => { + // #given + const content = "import { invoke } from '@/lib/ipc/invoke'" + + // #when + const total = countMemryRefs(content) + + // #then + expect(total).toBe(0) + }) }) describe('isTestFile', () => { diff --git a/apps/desktop-tauri/scripts/port-audit.ts b/apps/desktop-tauri/scripts/port-audit.ts index 0919f506f..ed7a41d2a 100644 --- a/apps/desktop-tauri/scripts/port-audit.ts +++ b/apps/desktop-tauri/scripts/port-audit.ts @@ -2,7 +2,13 @@ import { readFileSync, globSync } from 'node:fs' import { resolve, relative, dirname } from 'node:path' import { fileURLToPath } from 'node:url' -export type HitKind = 'window.api' | 'ipcRenderer' | 'electron-toolkit' | 'window.electron' +export type HitKind = + | 'window.api' + | 'ipcRenderer' + | 'electron-toolkit' + | 'window.electron' + | 'electron-log' + | 'electron-import' export interface Hit { file: string @@ -15,7 +21,11 @@ const PATTERNS: Array<{ kind: HitKind; regex: RegExp }> = [ { kind: 'window.api', regex: /window\.api\./ }, { kind: 'ipcRenderer', regex: /\bipcRenderer\b/ }, { kind: 'electron-toolkit', regex: /@electron-toolkit/ }, - { kind: 'window.electron', regex: /window\.electron\b/ } + { kind: 'window.electron', regex: /window\.electron\b/ }, + // Phase G hardening: catch leftover electron-log/* renderer imports. + { kind: 'electron-log', regex: /['"]electron-log(?:\/[a-z]+)?['"]/ }, + // Phase G hardening: bare `from 'electron'` / `from "electron"` imports. + { kind: 'electron-import', regex: /from\s+['"]electron['"]/ } ] /** @@ -42,6 +52,19 @@ export function isTestFile(relPath: string): boolean { return /\.test\.(ts|tsx)$/.test(relPath) } +/** + * Counts how many lines reference a `@memry/` workspace import. + * + * Phase G doesn't drive these to zero (legitimate `@memry/contracts` uses + * remain), but we track totals as a carry-forward ledger for the PR — later + * milestones graduate `@memry/rpc/*`, `@memry/db-schema/*`, and + * `@memry/shared/*` references away from the renderer. + */ +export function countMemryRefs(content: string): number { + const re = /@memry\//g + return [...content.matchAll(re)].length +} + function runCli(): void { const here = dirname(fileURLToPath(import.meta.url)) const root = resolve(here, '../src') @@ -55,9 +78,11 @@ function runCli(): void { .map((relPath) => resolve(root, relPath)) const hits: Hit[] = [] + let memryRefs = 0 for (const file of files) { const content = readFileSync(file, 'utf-8') hits.push(...scanContent(content, file)) + memryRefs += countMemryRefs(content) } console.log(`Total hits: ${hits.length}`) @@ -80,6 +105,8 @@ function runCli(): void { .forEach(([f, c]) => console.log(` ${c.toString().padStart(4)} ${relative(root, f)}`)) } + console.log(`\n@memry/* references (informational): ${memryRefs}`) + if (hits.length > 0) { process.exitCode = 1 } diff --git a/apps/desktop-tauri/scripts/schema-diff.ts b/apps/desktop-tauri/scripts/schema-diff.ts new file mode 100644 index 000000000..34c9dbf69 --- /dev/null +++ b/apps/desktop-tauri/scripts/schema-diff.ts @@ -0,0 +1,98 @@ +#!/usr/bin/env tsx +/** + * Compare Electron's applied schema against Tauri's applied schema. + * + * Run Tauri once (in any MEMRY_DEVICE profile) so it produces a freshly + * migrated DB, then point this script at both DBs. Reports any differences + * in table set, column set per table, or index set per table. + * + * Usage: + * pnpm db:schema-diff + */ +import Database from 'better-sqlite3' + +type TableInfo = { + name: string + columns: Set + indexes: Set +} + +function introspect(path: string): Map { + const db = new Database(path, { readonly: true }) + const tables = db + .prepare( + `SELECT name FROM sqlite_master + WHERE type='table' AND name NOT LIKE 'sqlite_%'`, + ) + .all() as Array<{ name: string }> + + const out = new Map() + for (const { name } of tables) { + const cols = db.prepare(`PRAGMA table_info(${name})`).all() as Array<{ name: string }> + const idx = db.prepare(`PRAGMA index_list(${name})`).all() as Array<{ name: string }> + out.set(name, { + name, + columns: new Set(cols.map((c) => c.name)), + indexes: new Set(idx.map((i) => i.name)), + }) + } + db.close() + return out +} + +function diffSet(a: Set, b: Set): { onlyA: T[]; onlyB: T[] } { + return { + onlyA: [...a].filter((x) => !b.has(x)), + onlyB: [...b].filter((x) => !a.has(x)), + } +} + +function main() { + const [electronPath, tauriPath] = process.argv.slice(2) + if (!electronPath || !tauriPath) { + console.error('Usage: pnpm db:schema-diff ') + process.exit(1) + } + + const electron = introspect(electronPath) + const tauri = introspect(tauriPath) + + const tableDiff = diffSet(new Set(electron.keys()), new Set(tauri.keys())) + + let failed = false + if (tableDiff.onlyA.length > 0) { + console.log(`Tables only in Electron: ${tableDiff.onlyA.join(', ')}`) + failed = true + } + if (tableDiff.onlyB.length > 0) { + console.log(`Tables only in Tauri: ${tableDiff.onlyB.join(', ')}`) + failed = true + } + + for (const [name, tInfo] of tauri) { + const eInfo = electron.get(name) + if (!eInfo) continue + const colDiff = diffSet(eInfo.columns, tInfo.columns) + if (colDiff.onlyA.length || colDiff.onlyB.length) { + console.log(`\nTable ${name} column diff:`) + if (colDiff.onlyA.length) console.log(` only in Electron: ${colDiff.onlyA.join(', ')}`) + if (colDiff.onlyB.length) console.log(` only in Tauri: ${colDiff.onlyB.join(', ')}`) + failed = true + } + const idxDiff = diffSet(eInfo.indexes, tInfo.indexes) + if (idxDiff.onlyA.length || idxDiff.onlyB.length) { + console.log(`\nTable ${name} index diff:`) + if (idxDiff.onlyA.length) console.log(` only in Electron: ${idxDiff.onlyA.join(', ')}`) + if (idxDiff.onlyB.length) console.log(` only in Tauri: ${idxDiff.onlyB.join(', ')}`) + failed = true + } + } + + if (failed) { + console.log('\nFAIL: schemas diverge.') + process.exit(1) + } + console.log('OK: schemas identical.') +} + +main() diff --git a/apps/desktop-tauri/src-tauri/src/bin/generate_bindings.rs b/apps/desktop-tauri/src-tauri/src/bin/generate_bindings.rs index b5af60929..b695ee4b3 100644 --- a/apps/desktop-tauri/src-tauri/src/bin/generate_bindings.rs +++ b/apps/desktop-tauri/src-tauri/src/bin/generate_bindings.rs @@ -20,6 +20,7 @@ fn main() -> Result<(), Box> { commands::settings::settings_get, commands::settings::settings_set, commands::settings::settings_list, + commands::lifecycle::notify_flush_done, ]) .typ::() .typ::() diff --git a/apps/desktop-tauri/src-tauri/src/commands/lifecycle.rs b/apps/desktop-tauri/src-tauri/src/commands/lifecycle.rs new file mode 100644 index 000000000..2b05c0911 --- /dev/null +++ b/apps/desktop-tauri/src-tauri/src/commands/lifecycle.rs @@ -0,0 +1,15 @@ +use crate::error::AppResult; + +/// Renderer→main signal that pending save flushes finished. +/// +/// At M2 there is no quit-orchestration coordinator on the Rust side; the M8.0 +/// lifecycle milestone introduces a flush coordinator that gates window close +/// on this notification. Until then the command is a thin no-op acknowledgement +/// so the renderer's `useFlushOnQuit` hook can keep its existing contract +/// without 404s through the mock router. +#[tauri::command] +#[specta::specta] +pub async fn notify_flush_done() -> AppResult<()> { + tracing::debug!("notify_flush_done received (M2 no-op)"); + Ok(()) +} diff --git a/apps/desktop-tauri/src-tauri/src/commands/mod.rs b/apps/desktop-tauri/src-tauri/src/commands/mod.rs index 90fab4db0..62b4a8205 100644 --- a/apps/desktop-tauri/src-tauri/src/commands/mod.rs +++ b/apps/desktop-tauri/src-tauri/src/commands/mod.rs @@ -2,10 +2,13 @@ //! //! Phase F (M2) introduces the first real feature-domain slice — settings — //! crossing the boundary via `settings_get` / `settings_set` / `settings_list`. +//! Phase G adds a single shell-neutral wrapper (`notify_flush_done`) so the +//! renderer's quit-flush hook does not 404 through the mock router. //! Every other domain still serves data through the JS-side mock router in //! `src/lib/ipc/mocks/`. As each domain's Rust implementation lands, declare //! its module here and add the command names to the `generate_handler!` macro //! invocation in `lib.rs::run` plus `realCommands` in //! `src/lib/ipc/invoke.ts`. +pub mod lifecycle; pub mod settings; diff --git a/apps/desktop-tauri/src-tauri/src/lib.rs b/apps/desktop-tauri/src-tauri/src/lib.rs index 7737dfb3b..c1fca3699 100644 --- a/apps/desktop-tauri/src-tauri/src/lib.rs +++ b/apps/desktop-tauri/src-tauri/src/lib.rs @@ -47,6 +47,7 @@ pub fn run() { commands::settings::settings_get, commands::settings::settings_set, commands::settings::settings_list, + commands::lifecycle::notify_flush_done, ]) .run(tauri::generate_context!()) .expect("error while running tauri application"); diff --git a/apps/desktop-tauri/src/generated/bindings.ts b/apps/desktop-tauri/src/generated/bindings.ts index b1621fc9f..2e1f3e89e 100644 --- a/apps/desktop-tauri/src/generated/bindings.ts +++ b/apps/desktop-tauri/src/generated/bindings.ts @@ -7,6 +7,16 @@ export const commands = { settingsGet: (input: SettingsGetInput) => typedError(__TAURI_INVOKE("settings_get", { input })), settingsSet: (input: SettingsSetInput) => typedError(__TAURI_INVOKE("settings_set", { input })), settingsList: () => typedError(__TAURI_INVOKE("settings_list")), + /** + * Renderer→main signal that pending save flushes finished. + * + * At M2 there is no quit-orchestration coordinator on the Rust side; the M8.0 + * lifecycle milestone introduces a flush coordinator that gates window close + * on this notification. Until then the command is a thin no-op acknowledgement + * so the renderer's `useFlushOnQuit` hook can keep its existing contract + * without 404s through the mock router. + */ + notifyFlushDone: () => typedError(__TAURI_INVOKE("notify_flush_done")), }; /* Types */ diff --git a/apps/desktop-tauri/src/lib/ipc/invoke.ts b/apps/desktop-tauri/src/lib/ipc/invoke.ts index 0553ea068..6e296546f 100644 --- a/apps/desktop-tauri/src/lib/ipc/invoke.ts +++ b/apps/desktop-tauri/src/lib/ipc/invoke.ts @@ -29,7 +29,8 @@ export async function invoke( const realCommands = new Set([ 'settings_get', 'settings_set', - 'settings_list' + 'settings_list', + 'notify_flush_done' ]) function shouldUseMock(cmd: string): boolean { diff --git a/apps/desktop-tauri/src/lib/ipc/mocks/updater.test.ts b/apps/desktop-tauri/src/lib/ipc/mocks/updater.test.ts index 57d2db837..32ef7a140 100644 --- a/apps/desktop-tauri/src/lib/ipc/mocks/updater.test.ts +++ b/apps/desktop-tauri/src/lib/ipc/mocks/updater.test.ts @@ -1,49 +1,60 @@ -import { describe, it, expect } from 'vitest' +import type { AppUpdateState } from '@memry/contracts/ipc-updater' +import { describe, expect, it } from 'vitest' import { updaterRoutes } from './updater' +async function call(name: keyof typeof updaterRoutes, args?: unknown): Promise { + const handler = updaterRoutes[name] + if (!handler) throw new Error(`route ${String(name)} not registered`) + return handler(args) +} + describe('updaterRoutes', () => { - it('updater_check returns a no-update-available response by default', async () => { - const res = (await updaterRoutes.updater_check!(undefined)) as { - available: boolean - currentVersion: string - latestVersion: string | null - } - expect(res.available).toBe(false) - expect(typeof res.currentVersion).toBe('string') + it('updater_get_state returns the AppUpdateState shape with status="unavailable"', async () => { + // #given the M2 mock has no real update surface + // #when the renderer asks for current state + const res = (await call('updater_get_state')) as AppUpdateState + + // #then it gets a fully populated AppUpdateState + expect(res).toMatchObject({ + currentVersion: '2.0.0-alpha.1', + updateSupported: false, + availableVersion: null + }) + expect(['unavailable', 'idle', 'up-to-date']).toContain(res.status) }) - it('updater_download returns ok with a mocked progress report', async () => { - const res = (await updaterRoutes.updater_download!(undefined)) as { - ok: boolean - progress: number - } - expect(res.ok).toBe(true) - expect(typeof res.progress).toBe('number') + it('updater_check_for_updates marks state up-to-date and stamps lastCheckedAt', async () => { + // #when the renderer triggers a check + const res = (await call('updater_check_for_updates')) as AppUpdateState + + // #then the mock reports up-to-date and records the check time + expect(res.status).toBe('up-to-date') + expect(typeof res.lastCheckedAt).toBe('number') + expect(res.error).toBeNull() }) - it('updater_install returns ok but notes m1 cannot actually install', async () => { - const res = (await updaterRoutes.updater_install!(undefined)) as { - ok: boolean - reason: string - } - expect(res.ok).toBe(false) - expect(res.reason).toMatch(/m1/i) + it('updater_download_update returns a no-op state because updates are unsupported in M2', async () => { + // #when the renderer asks to download + const res = (await call('updater_download_update')) as AppUpdateState + + // #then the mock returns the AppUpdateState shape unchanged + expect(res.updateSupported).toBe(false) + expect(res.availableVersion).toBeNull() }) - it('updater_settings_get returns the updater settings', async () => { - const settings = (await updaterRoutes.updater_settings_get!(undefined)) as { - autoCheck: boolean - channel: string - } - expect(typeof settings.autoCheck).toBe('boolean') - expect(typeof settings.channel).toBe('string') + it('updater_quit_and_install resolves to undefined because there is nothing to install', async () => { + // #when the renderer asks to install + const res = await call('updater_quit_and_install') + + // #then the route resolves without payload + expect(res).toBeUndefined() }) - it('updater_settings_update merges the patch', async () => { - const settings = (await updaterRoutes.updater_settings_update!({ - autoCheck: false - })) as { autoCheck: boolean } - expect(settings.autoCheck).toBe(false) + it('legacy updater_check / updater_download / updater_install routes are removed', () => { + // #then the M2 mocks no longer expose the pre-M1 names + expect(updaterRoutes).not.toHaveProperty('updater_check') + expect(updaterRoutes).not.toHaveProperty('updater_download') + expect(updaterRoutes).not.toHaveProperty('updater_install') }) }) diff --git a/apps/desktop-tauri/src/lib/ipc/mocks/updater.ts b/apps/desktop-tauri/src/lib/ipc/mocks/updater.ts index 1ad5c546f..904d968dc 100644 --- a/apps/desktop-tauri/src/lib/ipc/mocks/updater.ts +++ b/apps/desktop-tauri/src/lib/ipc/mocks/updater.ts @@ -1,40 +1,45 @@ +import type { AppUpdateState } from '@memry/contracts/ipc-updater' import type { MockRouteMap } from './types' -interface UpdaterSettings { - autoCheck: boolean - channel: 'stable' | 'beta' | 'nightly' - lastCheckedAt: number | null -} +const CURRENT_VERSION = '2.0.0-alpha.1' -let settings: UpdaterSettings = { - autoCheck: true, - channel: 'stable', - lastCheckedAt: null +const baseState: AppUpdateState = { + currentVersion: CURRENT_VERSION, + status: 'unavailable', + updateSupported: false, + availableVersion: null, + releaseName: null, + releaseDate: null, + releaseNotes: null, + downloadProgressPercent: null, + lastCheckedAt: null, + error: null } -const currentVersion = '2.0.0-alpha.1' +let state: AppUpdateState = { ...baseState } + +function snapshot(): AppUpdateState { + return { ...state } +} +/** + * Mock surface for the auto-updater. The real Tauri command shim lands in M9 + * (auto-update milestone); until then `useAppUpdater` calls these mocked + * routes and observes that updates are not supported. The shape MUST match + * `AppUpdateState` from `@memry/contracts/ipc-updater` so future renderer + * tightening (e.g. discriminated union changes) breaks tests instead of + * silently disagreeing with the hook. + */ export const updaterRoutes: MockRouteMap = { - updater_check: async () => { - settings = { ...settings, lastCheckedAt: Date.now() } - return { - available: false, - currentVersion, - latestVersion: null, - releaseNotes: null, - checkedAt: settings.lastCheckedAt - } + updater_get_state: async () => snapshot(), + updater_check_for_updates: async () => { + state = { ...state, status: 'up-to-date', lastCheckedAt: Date.now(), error: null } + return snapshot() + }, + updater_download_update: async () => { + // Updater-not-supported in M2; returning the same state keeps the renderer + // banner inert without surfacing an error. + return snapshot() }, - updater_download: async () => ({ ok: true, progress: 0 }), - updater_install: async () => ({ - ok: false, - reason: 'updater-not-implemented-in-m1' - }), - updater_cancel: async () => ({ ok: true }), - updater_settings_get: async () => settings, - updater_settings_update: async (args) => { - const patch = args as Partial - settings = { ...settings, ...patch } - return settings - } + updater_quit_and_install: async () => undefined } diff --git a/apps/desktop-tauri/src/lib/logger.ts b/apps/desktop-tauri/src/lib/logger.ts index 2a25f9ba4..39d06c46f 100644 --- a/apps/desktop-tauri/src/lib/logger.ts +++ b/apps/desktop-tauri/src/lib/logger.ts @@ -1,7 +1,56 @@ -import log from 'electron-log/renderer' +/** + * Renderer-side logger for the Tauri build. + * + * Replaces the Electron-era `electron-log/renderer` import. M2 keeps the API + * surface identical (`createLogger(scope).info/.warn/.error/.debug`) so the + * 80+ call sites do not need to change. The implementation is a thin wrapper + * around `console.*` that prefixes each line with `[scope]` and gates + * `info` / `debug` behind dev mode so production builds stay quiet. + * + * Full Rust log forwarding (the `logging_forward` command shape from the + * design review) is deferred to M8.0 alongside the lifecycle/logging work; + * doing it earlier would require shipping a logging IPC channel before the + * crash-handler infrastructure that decides which lines to surface. + */ -function createLogger(scope: string) { - return log.scope(scope) +const isDev = (() => { + try { + return import.meta.env?.DEV === true + } catch { + return false + } +})() + +export interface ScopedLogger { + debug: (...args: unknown[]) => void + info: (...args: unknown[]) => void + warn: (...args: unknown[]) => void + error: (...args: unknown[]) => void +} + +function format(scope: string, level: string): string { + return `[${scope}] [${level}]` } -export { log, createLogger } +function createLogger(scope: string): ScopedLogger { + return { + debug: (...args) => { + if (!isDev) return + console.debug(format(scope, 'debug'), ...args) + }, + info: (...args) => { + if (!isDev) return + console.info(format(scope, 'info'), ...args) + }, + warn: (...args) => { + console.warn(format(scope, 'warn'), ...args) + }, + error: (...args) => { + console.error(format(scope, 'error'), ...args) + } + } +} + +const log: ScopedLogger = createLogger('app') + +export { createLogger, log } diff --git a/apps/desktop-tauri/src/lib/save-registry.test.ts b/apps/desktop-tauri/src/lib/save-registry.test.ts index b87b02ff6..2d77ef655 100644 --- a/apps/desktop-tauri/src/lib/save-registry.test.ts +++ b/apps/desktop-tauri/src/lib/save-registry.test.ts @@ -1,9 +1,5 @@ import { describe, it, expect, vi, beforeEach } from 'vitest' -vi.mock('electron-log/renderer', () => ({ - default: { scope: () => ({ info: vi.fn(), error: vi.fn(), warn: vi.fn(), debug: vi.fn() }) } -})) - import { registerPendingSave, unregisterPendingSave, diff --git a/apps/desktop-tauri/tests/setup-dom.ts b/apps/desktop-tauri/tests/setup-dom.ts index e3a408514..6b9a9dbaa 100644 --- a/apps/desktop-tauri/tests/setup-dom.ts +++ b/apps/desktop-tauri/tests/setup-dom.ts @@ -8,7 +8,11 @@ import { vi } from 'vitest' import { cleanup } from '@testing-library/react' import { afterEach } from 'vitest' -vi.mock('electron-log/renderer', () => { +// Tauri-safe logger replacement (was electron-log/renderer in M1). +// Tests assert against `.error.toHaveBeenCalledWith(...)`, so every method +// must be a spy. The real `@/lib/logger` impl wraps `console.*`; mocking it +// here keeps log noise out of test output and lets tests inspect calls. +vi.mock('@/lib/logger', () => { const createScopedLogger = () => ({ debug: vi.fn(), info: vi.fn(), @@ -17,13 +21,8 @@ vi.mock('electron-log/renderer', () => { }) return { - default: { - debug: vi.fn(), - info: vi.fn(), - warn: vi.fn(), - error: vi.fn(), - scope: vi.fn(() => createScopedLogger()) - } + createLogger: vi.fn(() => createScopedLogger()), + log: createScopedLogger() } }) diff --git a/pnpm-lock.yaml b/pnpm-lock.yaml index 09a902a26..cdff9d62a 100644 --- a/pnpm-lock.yaml +++ b/pnpm-lock.yaml @@ -973,6 +973,9 @@ importers: '@testing-library/user-event': specifier: ^14.6.1 version: 14.6.1(@testing-library/dom@10.4.1) + '@types/better-sqlite3': + specifier: ^7.6.13 + version: 7.6.13 '@types/node': specifier: ^25.2.2 version: 25.2.2 @@ -994,6 +997,9 @@ importers: autoprefixer: specifier: ^10.4.24 version: 10.4.24(postcss@8.5.8) + better-sqlite3: + specifier: ^12.6.2 + version: 12.6.2 eslint: specifier: ^9.39.2 version: 9.39.2(jiti@2.6.1) From ffa1835d2f43880777647f0211386eb9b1f04abd Mon Sep 17 00:00:00 2001 From: Kaan Karaca Date: Sun, 26 Apr 2026 01:52:44 +0300 Subject: [PATCH 24/25] m2(bench): 1000-row list query p50 < 20ms acceptance test --- apps/desktop-tauri/src-tauri/Cargo.toml | 5 + .../src-tauri/src/bin/bench_m2.rs | 94 +++++++++++++++++++ 2 files changed, 99 insertions(+) create mode 100644 apps/desktop-tauri/src-tauri/src/bin/bench_m2.rs diff --git a/apps/desktop-tauri/src-tauri/Cargo.toml b/apps/desktop-tauri/src-tauri/Cargo.toml index c25d06d93..f3805c146 100644 --- a/apps/desktop-tauri/src-tauri/Cargo.toml +++ b/apps/desktop-tauri/src-tauri/Cargo.toml @@ -45,6 +45,11 @@ tempfile = "3" name = "generate_bindings" path = "src/bin/generate_bindings.rs" +[[bin]] +name = "bench_m2" +path = "src/bin/bench_m2.rs" +required-features = ["test-helpers"] + [[test]] name = "migrations_test" required-features = ["test-helpers"] diff --git a/apps/desktop-tauri/src-tauri/src/bin/bench_m2.rs b/apps/desktop-tauri/src-tauri/src/bin/bench_m2.rs new file mode 100644 index 000000000..4e4aadbf1 --- /dev/null +++ b/apps/desktop-tauri/src-tauri/src/bin/bench_m2.rs @@ -0,0 +1,94 @@ +//! M2 acceptance bench — 1000-row list query p50 < 20ms. +//! +//! Spec §5.5: every M2 ship-gate sweep includes a release-build run of this +//! bench so SQLite-path regressions surface before merge. Debug builds are +//! ~10× slower on rusqlite (Risk #7) — use `cargo run --release`. +//! +//! Strategy: +//! 1. Open an in-memory DB via `Db::open_memory` (same migration runner + +//! WAL/foreign-key PRAGMAs as production minus journal_mode). +//! 2. Seed a single project, then 1000 tasks under it inside one +//! `unchecked_transaction` so all rows commit atomically. +//! 3. Warm-up: 5 list iterations (statement-cache priming). +//! 4. Measure: 100 iterations of the SELECT, recording per-iteration +//! `Instant` deltas in microseconds. +//! 5. Sort, report p50/p95, assert p50 < 20_000µs. +//! +//! Run: +//! cargo run --release --bin bench_m2 --features test-helpers + +use memry_desktop_tauri_lib::db::Db; +use std::time::Instant; + +const ROW_COUNT: usize = 1000; +const WARMUP_ITERS: usize = 5; +const MEASURE_ITERS: usize = 100; +const P50_THRESHOLD_US: u64 = 20_000; +const SELECT_QUERY: &str = "SELECT id, title, priority, position FROM tasks + WHERE project_id = 'bench-p' ORDER BY position + LIMIT 1000"; + +fn main() { + let db = Db::open_memory().expect("open memory db"); + let conn = db.conn().expect("acquire connection guard"); + + conn.execute( + "INSERT INTO projects (id, name, color) VALUES (?1, ?2, ?3)", + rusqlite::params!["bench-p", "Bench", "#000"], + ) + .expect("seed project"); + + { + let tx = conn.unchecked_transaction().expect("open seed tx"); + for i in 0..ROW_COUNT { + tx.execute( + "INSERT INTO tasks (id, project_id, title, priority, position) + VALUES (?1, ?2, ?3, ?4, ?5)", + rusqlite::params![ + format!("t{i}"), + "bench-p", + format!("Task {i}"), + 0, + i as i64 + ], + ) + .expect("seed task"); + } + tx.commit().expect("commit seed tx"); + } + + for _ in 0..WARMUP_ITERS { + let mut stmt = conn.prepare(SELECT_QUERY).expect("prepare warmup"); + let rows: Vec = stmt + .query_map([], |r| r.get::<_, String>(0)) + .expect("query warmup") + .filter_map(Result::ok) + .collect(); + assert_eq!(rows.len(), ROW_COUNT, "warmup row count"); + } + + let mut samples: Vec = Vec::with_capacity(MEASURE_ITERS); + for _ in 0..MEASURE_ITERS { + let start = Instant::now(); + let mut stmt = conn.prepare(SELECT_QUERY).expect("prepare measure"); + let rows: Vec = stmt + .query_map([], |r| r.get::<_, String>(0)) + .expect("query measure") + .filter_map(Result::ok) + .collect(); + assert_eq!(rows.len(), ROW_COUNT, "measured row count"); + samples.push(start.elapsed().as_micros() as u64); + } + + samples.sort_unstable(); + let p50 = samples[samples.len() / 2]; + let p95 = samples[(samples.len() * 95) / 100]; + println!("1000-row list: p50 = {}µs, p95 = {}µs", p50, p95); + + assert!( + p50 < P50_THRESHOLD_US, + "p50 {p50}µs exceeds {P50_THRESHOLD_US}µs (20ms) threshold" + ); + + println!("OK: M2 bench within budget."); +} From 52e14e6f1ba3d519ea218b91db8122f3125eb149 Mon Sep 17 00:00:00 2001 From: Kaan Karaca Date: Sun, 26 Apr 2026 02:20:36 +0300 Subject: [PATCH 25/25] m2(settings): implement settings_get/set/list commands with SQLite backing This commit introduces the first real feature-domain IPC slice for managing settings through a thin KV store backed by SQLite. It includes: - Implementation of settings_get, settings_set, and settings_list commands in Rust. - Database helpers for get/set/list operations with UPSERT semantics. - Integration of these commands into the Tauri command handler. - Tests covering various scenarios including missing keys and UTF-8 integrity. The mock router remains for other settings routes, with a transition to real Tauri commands planned for future milestones. --- .../2026-04-26-m3-vault-fs-and-watcher.md | 4639 +++++++++++++++++ prompts/m3/README.md | 125 + prompts/m3/m3-phase-a-foundation.md | 186 + prompts/m3/m3-phase-b-vault-core-io.md | 207 + prompts/m3/m3-phase-c-preferences-registry.md | 193 + .../m3/m3-phase-d-watcher-runtime-state.md | 220 + prompts/m3/m3-phase-e-tauri-commands.md | 245 + .../m3/m3-phase-f-protocol-and-dragdrop.md | 247 + .../m3-phase-g-bindings-renderer-bench-pr.md | 286 + 9 files changed, 6348 insertions(+) create mode 100644 docs/superpowers/plans/2026-04-26-m3-vault-fs-and-watcher.md create mode 100644 prompts/m3/README.md create mode 100644 prompts/m3/m3-phase-a-foundation.md create mode 100644 prompts/m3/m3-phase-b-vault-core-io.md create mode 100644 prompts/m3/m3-phase-c-preferences-registry.md create mode 100644 prompts/m3/m3-phase-d-watcher-runtime-state.md create mode 100644 prompts/m3/m3-phase-e-tauri-commands.md create mode 100644 prompts/m3/m3-phase-f-protocol-and-dragdrop.md create mode 100644 prompts/m3/m3-phase-g-bindings-renderer-bench-pr.md diff --git a/docs/superpowers/plans/2026-04-26-m3-vault-fs-and-watcher.md b/docs/superpowers/plans/2026-04-26-m3-vault-fs-and-watcher.md new file mode 100644 index 000000000..f28f52633 --- /dev/null +++ b/docs/superpowers/plans/2026-04-26-m3-vault-fs-and-watcher.md @@ -0,0 +1,4639 @@ +# M3 — Vault FS + File Watcher Implementation Plan + +> **For agentic workers:** REQUIRED SUB-SKILL: Use superpowers:subagent-driven-development (recommended) or superpowers:executing-plans to implement this plan task-by-task. Steps use checkbox (`- [ ]`) syntax for tracking. + +**Goal:** Land vault filesystem in Rust — atomic `.md` read/write, YAML frontmatter parse/serialize, `notify` watcher emitting `vault-changed` events, vault-rooted JSON preferences, multi-vault registry, and the full vault Tauri command surface (`vault_open` / `vault_close` / `vault_list_notes` / `vault_read_note` / `vault_write_note` / status / config / switch / remove / reveal). Settle the Tauri replacement for `memry-file://` (allowlisted, byte-range, missing-image fallback). Ship the native dialog/shell command set (folder picker, file picker, reveal in Finder, open external URL, open local attachment) replacing Electron `shell.*` and `dialog.*`. Run a drag-drop path-resolution spike so file imports work without the Electron-only `File.path`. Swap the renderer mock IPC over to real Rust for every command this milestone implements. The data DB stays at the OS app-data path established in M2 — vaults are file-tree-only. + +**Architecture:** New `src-tauri/src/vault/` module owns the runtime: `paths` (canonicalize + escape guard), `fs` (atomic write + safe read + list), `frontmatter` (serde_yaml_ng parse / serialize / property extraction), `notes_io` (high-level `read_note_from_disk` / `write_note_to_disk`), `preferences` (per-vault JSON config under `/.memry/config.json`), `registry` (multi-vault list persisted under `/memry-{device}/vaults.json`), `state` (current vault + status + watcher handle behind interior mutability), `watcher` (notify v6 with 150ms path-keyed debounce, emits via `AppHandle`). `AppState` extends from `{ db }` to `{ db, vault }`. Vault commands (`commands/vault.rs`) are thin async wrappers; native commands (`commands/shell.rs`, `commands/dialog.rs`) wrap `tauri-plugin-shell` and `tauri-plugin-dialog`. The `memry-file://` custom URI scheme is implemented as a Tauri URI scheme protocol handler in `lib.rs::run` with vault-allowlisted reads, byte-range support, and 1×1 transparent-PNG fallback for missing images. + +**Tech Stack:** notify 6.x (FSEvents on macOS), serde_yaml_ng 0.10 (maintained fork of serde_yaml), mime_guess 2.x, sha2 0.10 (content hash for change detection), dunce 1.x (path canonicalization), tauri-plugin-dialog 2.x, tauri-plugin-shell 2.x (already in deps), tokio fs/sync, tempfile (dev-deps already), Vitest, Playwright WebKit. + +**Parent spec:** `docs/superpowers/specs/2026-04-24-electron-to-tauri-full-migration-design.md` (§4 M3, §5 cross-cutting conventions) + +**Predecessor plan:** `docs/superpowers/plans/2026-04-25-m2-db-schemas-migrations.md` (must be merged before M3 starts) + +--- + +## Pre-flight checks (do these before Task 1) + +- [ ] M2 PR merged to `main`: `git log --oneline main | head -10` shows the `m2(*)` series ending with `m2(devx): add MEMRY_DEVICE=A/B dev scripts` +- [ ] Rust toolchain: `rustc --version` returns 1.95+; `cargo --version` works +- [ ] Node 24.x active: `node --version` returns v24.x +- [ ] pnpm 10.x active: `pnpm --version` returns 10.x +- [ ] `apps/desktop-tauri/` boots on M2 baseline: `pnpm --filter @memry/desktop-tauri dev` opens a window +- [ ] Cargo green on `main`: `pnpm --filter @memry/desktop-tauri cargo:check && pnpm --filter @memry/desktop-tauri cargo:clippy && pnpm --filter @memry/desktop-tauri cargo:test` all exit 0 +- [ ] Bindings stable: `pnpm --filter @memry/desktop-tauri bindings:check` exits 0 against `main` +- [ ] Settings round-trip works against the M2 real-IPC slice (manual smoke from settings UI) +- [ ] Create a worktree for M3 isolation (per user preference — feedback_worktree.md): + +```bash +git worktree add ../spike-tauri-m3 -b m3/vault-fs-and-watcher main +cd ../spike-tauri-m3 +``` + +From this point, every path is relative to `../spike-tauri-m3`. + +- [ ] Confirm a scratch test vault path is available (or create one): + +```bash +mkdir -p ~/memry-test-vault-m3/notes ~/memry-test-vault-m3/journal ~/memry-test-vault-m3/attachments +``` + +The plan reuses this folder for manual smokes and the Task 16 100-note bench. + +--- + +## File Structure + +Files created or modified in M3: + +``` +apps/desktop-tauri/ +├── src-tauri/ +│ ├── Cargo.toml Task 1 (deps added) +│ ├── tauri.conf.json Task 13 (memry-file uri scheme) +│ ├── capabilities/ +│ │ └── default.json Task 12, 14 (dialog + shell + drag-drop) +│ │ +│ └── src/ +│ ├── lib.rs Task 9, 11, 13, 14 (vault wiring + protocol + plugins) +│ ├── error.rs Task 2 (AppError vault variants + From impls) +│ ├── app_state.rs Task 9 (add VaultRuntime field) +│ │ +│ ├── vault/ +│ │ ├── mod.rs Task 2 (module skeleton + re-exports) +│ │ ├── paths.rs Task 3 (new — canonicalize + traversal guard) +│ │ ├── fs.rs Task 4 (new — atomic write + safe read + list) +│ │ ├── frontmatter.rs Task 5 (new — parse / serialize / properties) +│ │ ├── notes_io.rs Task 6 (new — high-level read/write note) +│ │ ├── preferences.rs Task 7 (new — vault-root JSON config) +│ │ ├── registry.rs Task 8 (new — multi-vault list at OS data dir) +│ │ ├── state.rs Task 9 (new — VaultRuntime + status) +│ │ └── watcher.rs Task 10 (new — notify with debounce) +│ │ +│ └── commands/ +│ ├── mod.rs Task 11, 12 (register vault + shell + dialog) +│ ├── vault.rs Task 11 (new — 13 vault_* commands) +│ ├── shell.rs Task 12 (new — open / reveal commands) +│ └── dialog.rs Task 12 (new — folder / file picker) +│ +├── src/ +│ ├── lib/ +│ │ ├── ipc/ +│ │ │ ├── invoke.ts Task 15 (vault_*/shell_*/dialog_* swap) +│ │ │ └── mocks/ +│ │ │ └── vault.ts Task 15 (kept for vault_reindex deferred mock) +│ │ └── memry-file.ts Task 13 (new — toMemryFileUrl helper) +│ ├── services/ +│ │ └── vault-service.ts Task 15 (real-IPC swap; same exports) +│ └── generated/ +│ └── bindings.ts Task 15 (regenerated) +│ +├── e2e/ +│ └── specs/ +│ └── m3-vault-smoke.spec.ts Task 15 (new — open/list/read/write smoke) +│ +└── src-tauri/ + └── tests/ + ├── vault_paths_test.rs Task 3 (new — traversal + symlink guard) + ├── vault_fs_test.rs Task 4 (new — atomic write + safe read) + ├── vault_frontmatter_test.rs Task 5 (new — Turkish + multiline YAML) + ├── vault_notes_io_test.rs Task 6 (new — round-trip + ID auto-generation) + ├── vault_preferences_test.rs Task 7 (new — read/write/migration) + ├── vault_registry_test.rs Task 8 (new — add/remove/switch) + ├── vault_watcher_test.rs Task 10 (new — debounce + event emission) + └── vault_bench.rs Task 16 (new — 100-note <500ms bench) +``` + +--- + +## Task 1: Add notify, serde_yaml_ng, mime_guess, sha2, dunce, dialog plugin + +**Files:** +- Modify: `apps/desktop-tauri/src-tauri/Cargo.toml` + +- [ ] **Step 1.1: Inspect current `[dependencies]`** + +Run: + +```bash +grep -nE '^(rusqlite|tauri-plugin-shell|tokio|serde|serde_json|thiserror)' apps/desktop-tauri/src-tauri/Cargo.toml +``` + +Expected: hits for each line listed in the regex. Confirms M2 deps present and you do not duplicate keys. + +- [ ] **Step 1.2: Append M3 deps to `[dependencies]`** + +Edit `apps/desktop-tauri/src-tauri/Cargo.toml`. Locate the `# Declared for later milestones — unused at M1 but compile-verified` comment block and add directly after it: + +```toml +# Vault FS + watcher (M3) +notify = { version = "6.1", default-features = false, features = ["macos_fsevents"] } +serde_yaml_ng = "0.10" +mime_guess = "2.0" +sha2 = "0.10" +dunce = "1.0" + +# Native dialog + shell plugins (M3) +tauri-plugin-dialog = "2" +``` + +Notes: +- `notify` v6 with `macos_fsevents` keeps the dep tree narrow; the `crossbeam-channel` default feature is dropped so we use Tokio's mpsc instead. +- `serde_yaml_ng` is the maintained fork of `serde_yaml` (the original was archived in 2024). YAML 1.1 frontmatter compatibility with Electron's `gray-matter` output is unchanged. +- `mime_guess` resolves `.md`/`.png`/`.jpg`/`.pdf`/`.mp3`/`.mp4` MIME types for the `memry-file://` protocol (Task 13). +- `sha2` powers `generate_content_hash` for change-detection parity with Electron's djb2 (we upgrade to SHA-256 — pre-production, free hash swap). +- `dunce` is a tiny crate that strips Windows `\\?\` prefixes from canonicalized paths. Even though M3 is macOS-only, it handles macOS edge cases where `std::fs::canonicalize` returns `/private/var/...` instead of `/var/...` after symlink resolution. Using `dunce::canonicalize` consistently makes the path-comparison guard in Task 3 resilient. +- `tauri-plugin-dialog` is the Tauri 2 native folder/file picker. Already vendored by the Tauri 2 install but the crate must be a Cargo dep. + +- [ ] **Step 1.3: Verify lockfile updates and compiles** + +```bash +cd apps/desktop-tauri/src-tauri && cargo check +``` + +Expected: `Finished `dev` profile`. New deps are declared but unused; no warnings. + +- [ ] **Step 1.4: Commit** + +```bash +git add apps/desktop-tauri/src-tauri/Cargo.toml apps/desktop-tauri/src-tauri/Cargo.lock +git commit -m "m3(deps): add notify, serde_yaml_ng, mime_guess, sha2, dunce, dialog plugin" +``` + +--- + +## Task 2: Extend `AppError` + scaffold `vault/` module skeleton + +**Files:** +- Modify: `apps/desktop-tauri/src-tauri/src/error.rs` +- Create: `apps/desktop-tauri/src-tauri/src/vault/mod.rs` +- Modify: `apps/desktop-tauri/src-tauri/src/lib.rs` + +- [ ] **Step 2.1: Add vault-specific error variants** + +Open `apps/desktop-tauri/src-tauri/src/error.rs`. Inside the `AppError` enum, after the `Validation(String)` variant, add: + +```rust + #[error("vault error: {0}")] + Vault(String), + #[error("path escape: {0}")] + PathEscape(String), + #[error("io error: {0}")] + Io(String), +``` + +Then below the existing `From` impl, replace it (the existing impl maps to `Internal`, which is wrong for filesystem context — vault paths surface IO errors all over the place): + +```rust +impl From for AppError { + fn from(err: std::io::Error) -> Self { + AppError::Io(err.to_string()) + } +} +``` + +And add new `From` impls below `From`: + +```rust +impl From for AppError { + fn from(err: serde_yaml_ng::Error) -> Self { + AppError::Validation(format!("yaml: {err}")) + } +} + +impl From for AppError { + fn from(err: notify::Error) -> Self { + AppError::Vault(format!("watcher: {err}")) + } +} +``` + +Verify the file compiles standalone: + +```bash +cd apps/desktop-tauri/src-tauri && cargo check +``` + +Expected: still passes (the new variants are unused but valid). + +- [ ] **Step 2.2: Create the vault module skeleton** + +Create `apps/desktop-tauri/src-tauri/src/vault/mod.rs`: + +```rust +//! Vault filesystem layer. +//! +//! Owns `.md` IO, frontmatter parse/serialize, the per-vault JSON +//! preferences blob, the multi-vault registry, and the live `notify` +//! watcher. Vault state (current path, watcher handle, status) lives in +//! `state::VaultRuntime`, held as `AppState.vault`. All commands in +//! `commands/vault.rs` are thin async wrappers that delegate here. +//! +//! Path discipline: every external path crosses through `paths.rs` +//! before any `fs.rs` call. There are no `tokio::fs` or `std::fs` calls +//! outside `fs.rs` and `preferences.rs`, so the canonicalize+escape +//! guard cannot be bypassed by accident. + +pub mod fs; +pub mod frontmatter; +pub mod notes_io; +pub mod paths; +pub mod preferences; +pub mod registry; +pub mod state; +pub mod watcher; + +pub use frontmatter::{NoteFrontmatter, ParsedNote}; +pub use notes_io::{NoteOnDisk, ReadNoteResult}; +pub use preferences::{VaultConfig, VaultPreferences}; +pub use registry::{VaultInfo, VaultRegistry}; +pub use state::{VaultRuntime, VaultStatus}; +``` + +- [ ] **Step 2.3: Wire the module into `lib.rs`** + +Open `apps/desktop-tauri/src-tauri/src/lib.rs`. After the existing `pub mod` declarations near the top, add: + +```rust +pub mod vault; +``` + +Verify: + +```bash +cd apps/desktop-tauri/src-tauri && cargo check +``` + +Expected: `error[E0583]: file not found for module` for each empty submodule. That is correct — the next tasks create them. Move on. + +- [ ] **Step 2.4: Stub each submodule so `cargo check` passes between tasks** + +Create each of these as a one-line empty file so the module tree compiles. Each gets fleshed out in Task 3-10. + +```bash +for name in paths fs frontmatter notes_io preferences registry state watcher; do + echo '//! Stubbed in Task 2; populated in later tasks.' \ + > apps/desktop-tauri/src-tauri/src/vault/$name.rs +done +``` + +- [ ] **Step 2.5: Stub re-exports do not exist yet — comment them out** + +Re-open `apps/desktop-tauri/src-tauri/src/vault/mod.rs` and comment out the `pub use` block until later tasks export the symbols: + +```rust +// Re-exports flesh out in later tasks: +// pub use frontmatter::{NoteFrontmatter, ParsedNote}; +// pub use notes_io::{NoteOnDisk, ReadNoteResult}; +// pub use preferences::{VaultConfig, VaultPreferences}; +// pub use registry::{VaultInfo, VaultRegistry}; +// pub use state::{VaultRuntime, VaultStatus}; +``` + +```bash +cd apps/desktop-tauri/src-tauri && cargo check +``` + +Expected: `Finished` with one or two `unused module` warnings. Acceptable for the scaffold step. + +- [ ] **Step 2.6: Commit** + +```bash +git add apps/desktop-tauri/src-tauri/src/error.rs apps/desktop-tauri/src-tauri/src/lib.rs apps/desktop-tauri/src-tauri/src/vault +git commit -m "m3(vault): scaffold module + extend AppError with Vault/PathEscape/Io" +``` + +--- + +## Task 3: Path safety helpers — canonicalize + traversal guard + +**Files:** +- Create: `apps/desktop-tauri/src-tauri/src/vault/paths.rs` +- Create: `apps/desktop-tauri/src-tauri/tests/vault_paths_test.rs` +- Modify: `apps/desktop-tauri/src-tauri/Cargo.toml` (add `[[test]]` entry) + +- [ ] **Step 3.1: Write the failing test file first** + +Create `apps/desktop-tauri/src-tauri/tests/vault_paths_test.rs`: + +```rust +use memry_desktop_tauri_lib::vault::paths; +use std::fs; +use std::os::unix::fs as unix_fs; + +fn make_vault() -> tempfile::TempDir { + let dir = tempfile::tempdir().unwrap(); + fs::create_dir_all(dir.path().join("notes")).unwrap(); + fs::create_dir_all(dir.path().join("journal")).unwrap(); + dir +} + +#[test] +fn rejects_dotdot_escape() { + let vault = make_vault(); + let bad = "../outside.md"; + let err = paths::resolve_in_vault(vault.path(), bad).unwrap_err(); + assert!(matches!(err, memry_desktop_tauri_lib::error::AppError::PathEscape(_))); +} + +#[test] +fn rejects_absolute_outside_vault() { + let vault = make_vault(); + let bad = "/etc/passwd"; + let err = paths::resolve_in_vault(vault.path(), bad).unwrap_err(); + assert!(matches!(err, memry_desktop_tauri_lib::error::AppError::PathEscape(_))); +} + +#[test] +fn allows_normal_relative_path() { + let vault = make_vault(); + let ok = paths::resolve_in_vault(vault.path(), "notes/hello.md").unwrap(); + assert!(ok.starts_with(vault.path())); + assert!(ok.ends_with("notes/hello.md")); +} + +#[test] +fn rejects_symlink_escape() { + let vault = make_vault(); + let outside = tempfile::tempdir().unwrap(); + let secret = outside.path().join("secret.md"); + fs::write(&secret, "secret").unwrap(); + let link_path = vault.path().join("notes").join("link.md"); + unix_fs::symlink(&secret, &link_path).unwrap(); + let err = paths::resolve_in_vault(vault.path(), "notes/link.md").unwrap_err(); + assert!(matches!(err, memry_desktop_tauri_lib::error::AppError::PathEscape(_))); +} + +#[test] +fn rejects_hidden_dot_memry_directory() { + let vault = make_vault(); + let err = paths::resolve_in_vault(vault.path(), ".memry/data.db").unwrap_err(); + assert!(matches!(err, memry_desktop_tauri_lib::error::AppError::PathEscape(_))); +} + +#[test] +fn rejects_unsupported_extension() { + let vault = make_vault(); + let err = paths::resolve_supported(vault.path(), "notes/hello.exe").unwrap_err(); + assert!(matches!(err, memry_desktop_tauri_lib::error::AppError::Validation(_))); +} + +#[test] +fn allows_supported_extensions() { + let vault = make_vault(); + for ext in ["md", "png", "jpg", "jpeg", "gif", "webp", "pdf", "mp3", "mp4", "wav", "mov"] { + let rel = format!("notes/hello.{ext}"); + paths::resolve_supported(vault.path(), &rel) + .unwrap_or_else(|e| panic!("{ext} should be supported: {e}")); + } +} + +#[test] +fn to_relative_path_normalizes_separators() { + let vault = make_vault(); + let abs = vault.path().join("notes").join("foo.md"); + let rel = paths::to_relative_path(vault.path(), &abs).unwrap(); + assert_eq!(rel, "notes/foo.md"); +} + +#[test] +fn to_relative_path_rejects_outside_vault() { + let vault = make_vault(); + let outside = std::path::PathBuf::from("/etc/passwd"); + assert!(paths::to_relative_path(vault.path(), &outside).is_none()); +} +``` + +- [ ] **Step 3.2: Register the test binary in `Cargo.toml`** + +Open `apps/desktop-tauri/src-tauri/Cargo.toml`. Below the existing `[[test]]` blocks (`migrations_test`, `settings_test`), add: + +```toml +[[test]] +name = "vault_paths_test" +required-features = ["test-helpers"] +``` + +- [ ] **Step 3.3: Run the test to confirm it fails (no implementation yet)** + +```bash +cd apps/desktop-tauri/src-tauri && cargo test --features test-helpers --test vault_paths_test +``` + +Expected: `error[E0432]: unresolved import `memry_desktop_tauri_lib::vault::paths`` plus undefined `resolve_in_vault` / `resolve_supported` / `to_relative_path` functions. RED. + +- [ ] **Step 3.4: Implement `vault/paths.rs`** + +Replace the stub `apps/desktop-tauri/src-tauri/src/vault/paths.rs` with: + +```rust +//! Vault path normalization + escape-guard. +//! +//! Every external path that crosses into vault FS goes through +//! `resolve_in_vault`. The function canonicalizes the input under the +//! vault root, refuses paths that escape via `..` or symlinks, and +//! refuses paths that touch the hidden `.memry/` app-internal folder. +//! `resolve_supported` adds an extension allowlist that matches the +//! Electron `isSupportedPath` check. +//! +//! Path strings inside the renderer are always vault-relative with +//! forward slashes (matches Electron's `normalizeRelativePath`). The +//! conversion to absolute happens here and stays internal to Rust. + +use crate::error::{AppError, AppResult}; +use std::path::{Component, Path, PathBuf}; + +const HIDDEN_APP_DIR: &str = ".memry"; + +const SUPPORTED_EXT: &[&str] = &[ + "md", "markdown", + "png", "jpg", "jpeg", "gif", "webp", "svg", + "pdf", + "mp3", "wav", "m4a", "ogg", + "mp4", "mov", "webm", +]; + +/// Normalize a vault-relative path to forward slashes. +pub fn normalize_relative(path: &str) -> String { + path.replace('\\', "/") +} + +/// Convert an absolute path inside `vault_root` to a forward-slashed +/// vault-relative path. Returns `None` if the path is outside the vault. +pub fn to_relative_path(vault_root: &Path, abs: &Path) -> Option { + let canonical_root = dunce::canonicalize(vault_root).ok()?; + let canonical_abs = dunce::canonicalize(abs).ok()?; + let stripped = canonical_abs.strip_prefix(&canonical_root).ok()?; + let s = stripped.to_string_lossy().replace('\\', "/"); + if s.is_empty() { + None + } else { + Some(s) + } +} + +/// Resolve a vault-relative path to an absolute path under `vault_root`. +/// Rejects: +/// - `..` segments anywhere in the input +/// - absolute inputs (must be vault-relative) +/// - paths whose first segment is `.memry/` +/// - paths whose canonical resolution lands outside the vault root +/// (catches symlink escapes; the symlink target is resolved before +/// the `starts_with` check) +pub fn resolve_in_vault(vault_root: &Path, rel: &str) -> AppResult { + let cleaned = normalize_relative(rel); + let candidate = Path::new(&cleaned); + + if candidate.is_absolute() { + return Err(AppError::PathEscape(format!( + "absolute path not allowed: {rel}" + ))); + } + + let mut depth: i32 = 0; + for component in candidate.components() { + match component { + Component::ParentDir => { + depth -= 1; + if depth < 0 { + return Err(AppError::PathEscape(format!("dotdot escape: {rel}"))); + } + } + Component::Normal(seg) => { + if depth == 0 && seg == HIDDEN_APP_DIR { + return Err(AppError::PathEscape(format!( + "hidden app dir not addressable: {rel}" + ))); + } + depth += 1; + } + Component::CurDir => {} + Component::RootDir | Component::Prefix(_) => { + return Err(AppError::PathEscape(format!( + "root component in relative path: {rel}" + ))); + } + } + } + + let vault_canonical = dunce::canonicalize(vault_root) + .map_err(|e| AppError::Vault(format!("vault root unreadable: {e}")))?; + let joined = vault_canonical.join(candidate); + + // Canonicalize if the file already exists; otherwise canonicalize + // the parent and re-attach the leaf. This handles "write a new file + // at notes/foo.md" while still catching symlink escapes on the + // existing parent. + let resolved = if joined.exists() { + dunce::canonicalize(&joined)? + } else if let Some(parent) = joined.parent() { + if parent.exists() { + let canon_parent = dunce::canonicalize(parent)?; + canon_parent.join(joined.file_name().ok_or_else(|| { + AppError::PathEscape(format!("missing file name: {rel}")) + })?) + } else { + // Parent does not exist either — assume the caller is + // about to create the directory tree. Use the joined path + // as-is; the caller's `create_dir_all` is responsible. + joined.clone() + } + } else { + joined.clone() + }; + + if !resolved.starts_with(&vault_canonical) { + return Err(AppError::PathEscape(format!( + "resolved path escaped vault: {rel}" + ))); + } + + Ok(resolved) +} + +/// `resolve_in_vault` plus an extension allowlist. Returns the absolute +/// path on success. +pub fn resolve_supported(vault_root: &Path, rel: &str) -> AppResult { + let resolved = resolve_in_vault(vault_root, rel)?; + let ext = resolved + .extension() + .and_then(|e| e.to_str()) + .map(|e| e.to_lowercase()) + .ok_or_else(|| AppError::Validation(format!("missing extension: {rel}")))?; + if !SUPPORTED_EXT.contains(&ext.as_str()) { + return Err(AppError::Validation(format!( + "unsupported extension: .{ext}" + ))); + } + Ok(resolved) +} + +/// Heuristic: is this a markdown file by extension? +pub fn is_markdown(path: &Path) -> bool { + path.extension() + .and_then(|e| e.to_str()) + .map(|e| matches!(e.to_lowercase().as_str(), "md" | "markdown")) + .unwrap_or(false) +} +``` + +- [ ] **Step 3.5: Re-run the test to verify it passes** + +```bash +cd apps/desktop-tauri/src-tauri && cargo test --features test-helpers --test vault_paths_test +``` + +Expected: `9 passed`. + +- [ ] **Step 3.6: Commit** + +```bash +git add apps/desktop-tauri/src-tauri/src/vault/paths.rs \ + apps/desktop-tauri/src-tauri/tests/vault_paths_test.rs \ + apps/desktop-tauri/src-tauri/Cargo.toml +git commit -m "m3(vault): paths.rs canonicalize + traversal/symlink/hidden-dir guard" +``` + +--- + +## Task 4: Atomic write + safe read + list (`vault/fs.rs`) + +**Files:** +- Create: `apps/desktop-tauri/src-tauri/src/vault/fs.rs` +- Create: `apps/desktop-tauri/src-tauri/tests/vault_fs_test.rs` +- Modify: `apps/desktop-tauri/src-tauri/Cargo.toml` (add `[[test]]` entry) + +- [ ] **Step 4.1: Write the failing test** + +Create `apps/desktop-tauri/src-tauri/tests/vault_fs_test.rs`: + +```rust +use memry_desktop_tauri_lib::vault::fs as vfs; +use memry_desktop_tauri_lib::vault::paths; +use std::fs; + +fn make_vault() -> tempfile::TempDir { + let dir = tempfile::tempdir().unwrap(); + fs::create_dir_all(dir.path().join("notes")).unwrap(); + dir +} + +#[tokio::test] +async fn atomic_write_creates_file() { + let vault = make_vault(); + let abs = paths::resolve_in_vault(vault.path(), "notes/hello.md").unwrap(); + vfs::atomic_write(&abs, "# hello\n").await.unwrap(); + let read_back = fs::read_to_string(&abs).unwrap(); + assert_eq!(read_back, "# hello\n"); +} + +#[tokio::test] +async fn atomic_write_replaces_existing_file() { + let vault = make_vault(); + let abs = paths::resolve_in_vault(vault.path(), "notes/hello.md").unwrap(); + vfs::atomic_write(&abs, "first").await.unwrap(); + vfs::atomic_write(&abs, "second").await.unwrap(); + let read_back = fs::read_to_string(&abs).unwrap(); + assert_eq!(read_back, "second"); +} + +#[tokio::test] +async fn atomic_write_creates_parent_dirs() { + let vault = make_vault(); + let abs = paths::resolve_in_vault(vault.path(), "notes/sub/deep/foo.md").unwrap(); + vfs::atomic_write(&abs, "x").await.unwrap(); + assert!(abs.exists()); +} + +#[tokio::test] +async fn atomic_write_cleans_up_temp_on_failure() { + let vault = make_vault(); + // Write a directory at the target path, then try to atomic-write a + // file there. The rename must fail and leave no `.tmp.` files + // in the parent. + let target_dir = vault.path().join("notes").join("blocking"); + fs::create_dir_all(&target_dir).unwrap(); + + let abs = vault.path().join("notes").join("blocking"); + let result = vfs::atomic_write(&abs, "x").await; + assert!(result.is_err()); + + let leftover: Vec<_> = fs::read_dir(vault.path().join("notes")) + .unwrap() + .filter_map(|e| e.ok()) + .filter(|e| e.file_name().to_string_lossy().starts_with('.')) + .filter(|e| e.file_name().to_string_lossy().contains(".tmp.")) + .collect(); + assert!(leftover.is_empty(), "temp file leaked: {leftover:?}"); +} + +#[tokio::test] +async fn safe_read_returns_none_for_missing() { + let vault = make_vault(); + let abs = vault.path().join("notes").join("missing.md"); + let result = vfs::safe_read(&abs).await.unwrap(); + assert!(result.is_none()); +} + +#[tokio::test] +async fn safe_read_returns_content_for_existing() { + let vault = make_vault(); + let abs = vault.path().join("notes").join("hi.md"); + fs::write(&abs, "hi").unwrap(); + let result = vfs::safe_read(&abs).await.unwrap(); + assert_eq!(result.as_deref(), Some("hi")); +} + +#[tokio::test] +async fn list_supported_files_skips_hidden_and_unsupported() { + let vault = make_vault(); + fs::write(vault.path().join("notes/keep.md"), "k").unwrap(); + fs::write(vault.path().join("notes/.hidden.md"), "h").unwrap(); + fs::write(vault.path().join("notes/skip.exe"), "x").unwrap(); + fs::create_dir_all(vault.path().join(".memry")).unwrap(); + fs::write(vault.path().join(".memry/data.db"), "db").unwrap(); + let entries = vfs::list_supported_files(vault.path()).await.unwrap(); + let names: Vec<&str> = entries.iter().map(String::as_str).collect(); + assert!(names.contains(&"notes/keep.md")); + assert!(!names.iter().any(|n| n.contains(".hidden"))); + assert!(!names.iter().any(|n| n.ends_with(".exe"))); + assert!(!names.iter().any(|n| n.starts_with(".memry"))); +} + +#[test] +fn content_hash_is_stable_for_same_content() { + let h1 = vfs::content_hash("hello world"); + let h2 = vfs::content_hash("hello world"); + assert_eq!(h1, h2); + assert_eq!(h1.len(), 64); // sha256 hex +} + +#[test] +fn content_hash_differs_for_different_content() { + assert_ne!(vfs::content_hash("a"), vfs::content_hash("b")); +} +``` + +- [ ] **Step 4.2: Register the test in `Cargo.toml`** + +Append below the existing `[[test]]` blocks: + +```toml +[[test]] +name = "vault_fs_test" +required-features = ["test-helpers"] +``` + +- [ ] **Step 4.3: Run the test (RED)** + +```bash +cd apps/desktop-tauri/src-tauri && cargo test --features test-helpers --test vault_fs_test +``` + +Expected: unresolved imports for `atomic_write`, `safe_read`, `list_supported_files`, `content_hash`. RED. + +- [ ] **Step 4.4: Implement `vault/fs.rs`** + +Replace the stub `apps/desktop-tauri/src-tauri/src/vault/fs.rs` with: + +```rust +//! Filesystem ops for the vault layer. +//! +//! - `atomic_write`: temp-file-then-rename pattern. Survives mid-write +//! crash because the partial temp file is never visible at the final +//! path. POSIX `rename(2)` is atomic on the same filesystem; on +//! macOS the .memry-internal data DB and the vault tree are usually +//! on the same APFS volume. +//! - `safe_read`: returns `None` for missing files, errors otherwise. +//! - `list_supported_files`: depth-first walk that skips hidden +//! entries (`.foo`), `.memry` app-internal dir, and unsupported +//! extensions. Output is forward-slashed vault-relative paths. +//! - `content_hash`: SHA-256 hex of UTF-8 bytes for change detection. +//! +//! All functions receive already-canonicalized absolute paths from +//! `vault::paths::resolve_in_vault` — they do NOT re-validate. + +use crate::error::{AppError, AppResult}; +use crate::vault::paths; +use sha2::{Digest, Sha256}; +use std::path::{Path, PathBuf}; +use tokio::fs; + +const TEMP_PREFIX: &str = ".tmp."; + +/// Atomically write `content` to `path`. Creates parent dirs as needed. +/// On failure, removes any leftover temp file in the same parent. +pub async fn atomic_write(path: &Path, content: &str) -> AppResult<()> { + let parent = path.parent().ok_or_else(|| { + AppError::Vault(format!("path has no parent: {}", path.display())) + })?; + fs::create_dir_all(parent).await?; + + let suffix = nanoid::nanoid!(12); + let temp_name = format!("{TEMP_PREFIX}{suffix}"); + let temp_path = parent.join(temp_name); + + let write_then_rename = async { + fs::write(&temp_path, content).await?; + fs::rename(&temp_path, path).await?; + Ok::<_, AppError>(()) + }; + + match write_then_rename.await { + Ok(()) => Ok(()), + Err(e) => { + let _ = fs::remove_file(&temp_path).await; + Err(e) + } + } +} + +/// Read a file as UTF-8. Returns `Ok(None)` if the file does not exist. +/// Other IO errors propagate as `AppError::Io`. +pub async fn safe_read(path: &Path) -> AppResult> { + match fs::read_to_string(path).await { + Ok(s) => Ok(Some(s)), + Err(e) if e.kind() == std::io::ErrorKind::NotFound => Ok(None), + Err(e) => Err(AppError::from(e)), + } +} + +/// Read a file or error if missing. +pub async fn read_required(path: &Path) -> AppResult { + safe_read(path).await?.ok_or_else(|| { + AppError::NotFound(format!("file not found: {}", path.display())) + }) +} + +/// Delete a file. No-op if it does not exist. +pub async fn delete_file(path: &Path) -> AppResult<()> { + match fs::remove_file(path).await { + Ok(()) => Ok(()), + Err(e) if e.kind() == std::io::ErrorKind::NotFound => Ok(()), + Err(e) => Err(AppError::from(e)), + } +} + +/// List every supported file under `vault_root`, returning forward- +/// slashed vault-relative paths sorted lexicographically. Skips: +/// - any directory or file whose basename starts with `.` +/// - the `.memry/` app-internal dir at the vault root +/// - unsupported file extensions (matches `paths::resolve_supported`) +/// - symlinks (defense in depth — `paths::resolve_in_vault` already +/// rejects symlink targets that escape, but the watcher walk skips +/// symlinks entirely so a symlink loop cannot DOS the scan) +pub async fn list_supported_files(vault_root: &Path) -> AppResult> { + let canonical_root = dunce::canonicalize(vault_root)?; + let mut out: Vec = Vec::new(); + let mut stack: Vec = vec![canonical_root.clone()]; + + while let Some(dir) = stack.pop() { + let mut entries = match fs::read_dir(&dir).await { + Ok(e) => e, + Err(e) if e.kind() == std::io::ErrorKind::PermissionDenied => continue, + Err(e) => return Err(AppError::from(e)), + }; + while let Some(entry) = entries.next_entry().await? { + let name = entry.file_name(); + let name_str = name.to_string_lossy(); + if name_str.starts_with('.') { + continue; + } + let metadata = match entry.metadata().await { + Ok(m) => m, + Err(_) => continue, + }; + let path = entry.path(); + if metadata.file_type().is_symlink() { + continue; + } + if metadata.is_dir() { + stack.push(path); + } else if metadata.is_file() { + let lower_ext = path + .extension() + .and_then(|e| e.to_str()) + .map(|e| e.to_lowercase()) + .unwrap_or_default(); + if lower_ext.is_empty() { + continue; + } + if !paths::resolve_supported(&canonical_root, &format!("dummy.{lower_ext}")) + .is_ok() + && !paths::is_markdown(&path) + && !is_supported_attachment(&lower_ext) + { + continue; + } + if let Some(rel) = paths::to_relative_path(&canonical_root, &path) { + out.push(rel); + } + } + } + } + + out.sort(); + Ok(out) +} + +fn is_supported_attachment(ext: &str) -> bool { + matches!( + ext, + "png" | "jpg" | "jpeg" | "gif" | "webp" | "svg" | + "pdf" | "mp3" | "wav" | "m4a" | "ogg" | "mp4" | "mov" | "webm" + ) +} + +/// SHA-256 hex of `content`. Used by the watcher and notes_io to skip +/// no-op rewrites and emit `vault-changed` only on real diffs. +pub fn content_hash(content: &str) -> String { + let mut hasher = Sha256::new(); + hasher.update(content.as_bytes()); + let digest = hasher.finalize(); + let mut hex = String::with_capacity(64); + for byte in digest { + hex.push_str(&format!("{byte:02x}")); + } + hex +} +``` + +- [ ] **Step 4.5: Add `nanoid` to Cargo.toml** + +`atomic_write` uses `nanoid::nanoid!` for temp-file suffixes. Add to `[dependencies]`: + +```toml +nanoid = "0.4" +``` + +- [ ] **Step 4.6: Run tests until green** + +```bash +cd apps/desktop-tauri/src-tauri && cargo test --features test-helpers --test vault_fs_test +``` + +Expected: `9 passed`. If `atomic_write_cleans_up_temp_on_failure` is flaky, ensure the cleanup branch runs unconditionally on `Err` regardless of which step failed. + +- [ ] **Step 4.7: Commit** + +```bash +git add apps/desktop-tauri/src-tauri/src/vault/fs.rs \ + apps/desktop-tauri/src-tauri/tests/vault_fs_test.rs \ + apps/desktop-tauri/src-tauri/Cargo.toml \ + apps/desktop-tauri/src-tauri/Cargo.lock +git commit -m "m3(vault): fs.rs atomic_write + safe_read + list + sha256 content_hash" +``` + +--- + +## Task 5: Frontmatter parse + serialize (`vault/frontmatter.rs`) + +**Files:** +- Create: `apps/desktop-tauri/src-tauri/src/vault/frontmatter.rs` +- Create: `apps/desktop-tauri/src-tauri/tests/vault_frontmatter_test.rs` +- Modify: `apps/desktop-tauri/src-tauri/Cargo.toml` (add `[[test]]` entry, add `nanoid` reuse) + +- [ ] **Step 5.1: Write the failing test** + +Create `apps/desktop-tauri/src-tauri/tests/vault_frontmatter_test.rs`: + +```rust +use memry_desktop_tauri_lib::vault::frontmatter::{ + create_frontmatter, parse_note, serialize_note, NoteFrontmatter, +}; + +#[test] +fn parses_minimal_frontmatter() { + let raw = "---\nid: abc123\ntitle: Hello\ncreated: 2026-04-26T00:00:00Z\nmodified: 2026-04-26T00:00:00Z\n---\nbody"; + let parsed = parse_note(raw, Some("notes/hello.md")).unwrap(); + assert_eq!(parsed.frontmatter.id, "abc123"); + assert_eq!(parsed.frontmatter.title.as_deref(), Some("Hello")); + assert_eq!(parsed.content, "body"); + assert!(parsed.had_frontmatter); + assert!(!parsed.was_modified); +} + +#[test] +fn auto_generates_missing_required_fields() { + let raw = "no frontmatter here\n"; + let parsed = parse_note(raw, Some("notes/x.md")).unwrap(); + assert!(!parsed.frontmatter.id.is_empty()); + assert!(!parsed.frontmatter.created.is_empty()); + assert!(!parsed.frontmatter.modified.is_empty()); + assert!(parsed.was_modified); + assert_eq!(parsed.frontmatter.title.as_deref(), Some("X")); +} + +#[test] +fn extracts_title_from_filename_when_missing() { + let raw = "---\nid: x\ncreated: 2026-04-26T00:00:00Z\nmodified: 2026-04-26T00:00:00Z\n---\nbody"; + let parsed = parse_note(raw, Some("notes/my-cool-thought.md")).unwrap(); + assert_eq!(parsed.frontmatter.title.as_deref(), Some("My Cool Thought")); +} + +#[test] +fn turkish_chars_roundtrip_byte_identical() { + let title = "Toplantı: çay & kahve — ÖĞRENME günü"; + let body = "İçerik düzenlendi: çalışma & öğrenme."; + let mut fm = create_frontmatter(title, &["work".to_string()]); + fm.id = "fixed-id".to_string(); + let serialized = serialize_note(&fm, body).unwrap(); + let parsed = parse_note(&serialized, None).unwrap(); + assert_eq!(parsed.frontmatter.title.as_deref(), Some(title)); + assert_eq!(parsed.content, body); +} + +#[test] +fn multiline_yaml_string_roundtrip() { + let raw = "---\nid: x\ntitle: With Block\ncreated: 2026-04-26T00:00:00Z\nmodified: 2026-04-26T00:00:00Z\nproperties:\n description: |\n line one\n line two\n---\nbody"; + let parsed = parse_note(raw, None).unwrap(); + let props = parsed.frontmatter.properties.as_ref().unwrap(); + let desc = props.get("description").unwrap(); + assert!(desc.as_str().unwrap().contains("line one")); + assert!(desc.as_str().unwrap().contains("line two")); +} + +#[test] +fn date_field_preserved_as_string() { + let raw = "---\nid: x\ntitle: Dated\ncreated: 2026-04-26\nmodified: 2026-04-26T10:30:00Z\n---\nbody"; + let parsed = parse_note(raw, None).unwrap(); + assert_eq!(parsed.frontmatter.created, "2026-04-26"); + assert_eq!(parsed.frontmatter.modified, "2026-04-26T10:30:00Z"); +} + +#[test] +fn tags_normalized_to_vec_strings() { + let raw = "---\nid: x\ntitle: T\ncreated: 2026-04-26T00:00:00Z\nmodified: 2026-04-26T00:00:00Z\ntags:\n - work\n - life\n - WORK\n---\nbody"; + let parsed = parse_note(raw, None).unwrap(); + assert_eq!(parsed.frontmatter.tags, vec!["work", "life", "WORK"]); +} + +#[test] +fn preserves_non_reserved_properties_through_roundtrip() { + let raw = "---\nid: x\ntitle: T\ncreated: 2026-04-26T00:00:00Z\nmodified: 2026-04-26T00:00:00Z\nstatus: active\npriority: 3\n---\nbody"; + let parsed = parse_note(raw, None).unwrap(); + let serialized = serialize_note(&parsed.frontmatter, &parsed.content).unwrap(); + assert!(serialized.contains("status: active")); + assert!(serialized.contains("priority: 3")); +} + +#[test] +fn extract_properties_skips_reserved_keys() { + let raw = "---\nid: x\ntitle: T\ncreated: 2026-04-26T00:00:00Z\nmodified: 2026-04-26T00:00:00Z\ntags:\n - work\nstatus: active\nflag: true\n---\nbody"; + let parsed = parse_note(raw, None).unwrap(); + let props = parsed.frontmatter.extract_properties(); + assert!(props.contains_key("status")); + assert!(props.contains_key("flag")); + assert!(!props.contains_key("id")); + assert!(!props.contains_key("title")); + assert!(!props.contains_key("tags")); +} +``` + +- [ ] **Step 5.2: Register the test in `Cargo.toml`** + +```toml +[[test]] +name = "vault_frontmatter_test" +required-features = ["test-helpers"] +``` + +- [ ] **Step 5.3: Run RED** + +```bash +cd apps/desktop-tauri/src-tauri && cargo test --features test-helpers --test vault_frontmatter_test +``` + +Expected: unresolved imports. + +- [ ] **Step 5.4: Implement `vault/frontmatter.rs`** + +Replace the stub with: + +```rust +//! YAML frontmatter parser, serializer, and property extractor. +//! +//! Parser is gray-matter-compatible enough for Electron-authored +//! `.md` files: `---` fence at the start, YAML 1.1 between fences, +//! body after. Reserved frontmatter keys (id/title/created/modified/ +//! tags/aliases/emoji/local_only/properties) are pulled into the +//! typed `NoteFrontmatter` struct; everything else is extracted by +//! `extract_properties()` for the renderer's property-definitions +//! system. +//! +//! Required field auto-fill matches Electron's `parseNote`: missing +//! `id` → fresh nanoid; missing `created`/`modified` → now ISO; the +//! caller checks `was_modified` to know when to re-serialize. + +use crate::error::{AppError, AppResult}; +use serde_yaml_ng as yaml; +use serde_yaml_ng::Value; +use std::collections::BTreeMap; +use std::path::Path; + +const RESERVED_KEYS: &[&str] = &[ + "id", "title", "created", "modified", "tags", "aliases", "emoji", + "localOnly", "properties", +]; + +#[derive(Debug, Clone, serde::Serialize, serde::Deserialize, specta::Type)] +#[serde(rename_all = "camelCase")] +pub struct NoteFrontmatter { + pub id: String, + #[serde(default, skip_serializing_if = "Option::is_none")] + pub title: Option, + pub created: String, + pub modified: String, + #[serde(default, skip_serializing_if = "Vec::is_empty")] + pub tags: Vec, + #[serde(default, skip_serializing_if = "Vec::is_empty")] + pub aliases: Vec, + #[serde(default, skip_serializing_if = "Option::is_none")] + pub emoji: Option, + #[serde(default, skip_serializing_if = "Option::is_none")] + pub local_only: Option, + #[serde(default, skip_serializing_if = "Option::is_none")] + pub properties: Option>, + /// Catch-all for non-reserved keys (matches Electron's + /// "top-level keys are properties unless reserved"). + #[serde(flatten)] + pub extra: BTreeMap, +} + +impl NoteFrontmatter { + pub fn extract_properties(&self) -> BTreeMap { + if let Some(p) = &self.properties { + return p.clone(); + } + let mut out = BTreeMap::new(); + for (k, v) in &self.extra { + if !RESERVED_KEYS.contains(&k.as_str()) { + out.insert(k.clone(), v.clone()); + } + } + out + } +} + +#[derive(Debug, Clone, serde::Serialize, specta::Type)] +#[serde(rename_all = "camelCase")] +pub struct ParsedNote { + pub frontmatter: NoteFrontmatter, + pub content: String, + pub had_frontmatter: bool, + pub was_modified: bool, +} + +/// Parse a markdown file with optional YAML frontmatter. Auto-fills +/// required fields when missing. +pub fn parse_note(raw: &str, file_path: Option<&str>) -> AppResult { + let (mut yaml_text, body, had_frontmatter) = split_frontmatter(raw); + + let mut data: BTreeMap = if yaml_text.is_empty() { + BTreeMap::new() + } else { + yaml::from_str(&yaml_text).unwrap_or_default() + }; + let _ = &mut yaml_text; + + let now = current_iso(); + let mut was_modified = false; + + let id = match data.get("id").and_then(Value::as_str) { + Some(v) if !v.is_empty() => v.to_string(), + _ => { + was_modified = true; + generate_note_id() + } + }; + + let created = match data.get("created") { + Some(Value::String(s)) => s.clone(), + Some(other) => yaml_value_to_string(other), + None => { + was_modified = true; + now.clone() + } + }; + let modified = match data.get("modified") { + Some(Value::String(s)) => s.clone(), + Some(other) => yaml_value_to_string(other), + None => { + was_modified = true; + now.clone() + } + }; + + let title = data.get("title").and_then(Value::as_str).map(|s| s.to_string()).or_else(|| { + file_path.map(extract_title_from_path) + }); + + let tags = data + .get("tags") + .and_then(|v| v.as_sequence()) + .map(|seq| { + seq.iter() + .filter_map(|v| v.as_str().map(|s| s.to_string())) + .collect() + }) + .unwrap_or_default(); + + let aliases = data + .get("aliases") + .and_then(|v| v.as_sequence()) + .map(|seq| { + seq.iter() + .filter_map(|v| v.as_str().map(|s| s.to_string())) + .collect() + }) + .unwrap_or_default(); + + let emoji = data.get("emoji").and_then(Value::as_str).map(String::from); + let local_only = data.get("localOnly").and_then(Value::as_bool); + let properties = data + .get("properties") + .and_then(|v| v.as_mapping()) + .map(|map| { + let mut out = BTreeMap::new(); + for (k, v) in map.iter() { + if let Some(key) = k.as_str() { + out.insert(key.to_string(), v.clone()); + } + } + out + }); + + let mut extra = BTreeMap::new(); + for (k, v) in data.into_iter() { + if !RESERVED_KEYS.contains(&k.as_str()) { + extra.insert(k, v); + } + } + + let frontmatter = NoteFrontmatter { + id, + title, + created, + modified, + tags, + aliases, + emoji, + local_only, + properties, + extra, + }; + + Ok(ParsedNote { + frontmatter, + content: body.trim().to_string(), + had_frontmatter, + was_modified, + }) +} + +/// Serialize frontmatter + body back to a markdown file. Bumps +/// `modified` to now. +pub fn serialize_note(fm: &NoteFrontmatter, content: &str) -> AppResult { + let mut out = NoteFrontmatter { + modified: current_iso(), + ..fm.clone() + }; + let _ = &mut out; + + let mut map = BTreeMap::::new(); + map.insert("id".into(), Value::String(out.id.clone())); + if let Some(title) = &out.title { + map.insert("title".into(), Value::String(title.clone())); + } + map.insert("created".into(), Value::String(out.created.clone())); + map.insert("modified".into(), Value::String(out.modified.clone())); + if !out.tags.is_empty() { + map.insert( + "tags".into(), + Value::Sequence(out.tags.iter().map(|t| Value::String(t.clone())).collect()), + ); + } + if !out.aliases.is_empty() { + map.insert( + "aliases".into(), + Value::Sequence( + out.aliases.iter().map(|t| Value::String(t.clone())).collect(), + ), + ); + } + if let Some(emoji) = &out.emoji { + map.insert("emoji".into(), Value::String(emoji.clone())); + } + if let Some(b) = out.local_only { + map.insert("localOnly".into(), Value::Bool(b)); + } + if let Some(props) = &out.properties { + let mapping: yaml::Mapping = props + .iter() + .map(|(k, v)| (Value::String(k.clone()), v.clone())) + .collect(); + map.insert("properties".into(), Value::Mapping(mapping)); + } + for (k, v) in &out.extra { + if !map.contains_key(k) { + map.insert(k.clone(), v.clone()); + } + } + + let yaml_text = yaml::to_string(&map)?; + let body = content.trim_end_matches(['\n']).to_string(); + Ok(format!("---\n{yaml_text}---\n{body}")) +} + +/// Convenience: build a fresh frontmatter for a new note. +pub fn create_frontmatter(title: &str, tags: &[String]) -> NoteFrontmatter { + let now = current_iso(); + NoteFrontmatter { + id: generate_note_id(), + title: Some(title.to_string()), + created: now.clone(), + modified: now, + tags: tags.to_vec(), + aliases: Vec::new(), + emoji: None, + local_only: None, + properties: None, + extra: BTreeMap::new(), + } +} + +fn split_frontmatter(raw: &str) -> (String, String, bool) { + let trimmed = raw.trim_start_matches('\u{FEFF}'); + if !trimmed.starts_with("---") { + return (String::new(), trimmed.to_string(), false); + } + let after_open = &trimmed[3..]; + let after_open = after_open.trim_start_matches('\r').trim_start_matches('\n'); + if let Some(end_idx) = find_closing_fence(after_open) { + let yaml_text = after_open[..end_idx].to_string(); + let mut rest = &after_open[end_idx..]; + rest = rest.trim_start_matches("---"); + rest = rest.trim_start_matches('\r').trim_start_matches('\n'); + (yaml_text, rest.to_string(), true) + } else { + (String::new(), trimmed.to_string(), false) + } +} + +fn find_closing_fence(text: &str) -> Option { + let mut start = 0usize; + while let Some(idx) = text[start..].find("\n---") { + let candidate = start + idx + 1; + let after = &text[candidate + 3..]; + if after.is_empty() || after.starts_with('\r') || after.starts_with('\n') { + return Some(candidate); + } + start = candidate + 1; + } + None +} + +fn extract_title_from_path(path: &str) -> String { + let leaf = Path::new(path) + .file_stem() + .and_then(|s| s.to_str()) + .unwrap_or(path); + leaf.replace(['-', '_'], " ") + .split_whitespace() + .map(capitalize) + .collect::>() + .join(" ") +} + +fn capitalize(word: &str) -> String { + let mut chars = word.chars(); + match chars.next() { + None => String::new(), + Some(first) => { + let mut s = first.to_uppercase().collect::(); + s.push_str(chars.as_str()); + s + } + } +} + +fn current_iso() -> String { + use std::time::{SystemTime, UNIX_EPOCH}; + let secs = SystemTime::now() + .duration_since(UNIX_EPOCH) + .map(|d| d.as_secs()) + .unwrap_or(0); + // Minimal ISO-8601 formatter — avoids pulling in chrono just here. + let datetime = unix_secs_to_iso(secs); + datetime +} + +fn unix_secs_to_iso(secs: u64) -> String { + let days_per_month = |y: u64, m: u64| -> u64 { + let leap = (y % 4 == 0 && y % 100 != 0) || y % 400 == 0; + match m { + 1 | 3 | 5 | 7 | 8 | 10 | 12 => 31, + 4 | 6 | 9 | 11 => 30, + 2 => if leap { 29 } else { 28 }, + _ => 0, + } + }; + let mut s = secs; + let secs_part = s % 60; + s /= 60; + let mins_part = s % 60; + s /= 60; + let hours_part = s % 24; + s /= 24; + let mut year: u64 = 1970; + loop { + let leap = (year % 4 == 0 && year % 100 != 0) || year % 400 == 0; + let yd = if leap { 366 } else { 365 }; + if s < yd { break; } + s -= yd; + year += 1; + } + let mut month: u64 = 1; + while month <= 12 { + let md = days_per_month(year, month); + if s < md { break; } + s -= md; + month += 1; + } + let day = s + 1; + format!("{year:04}-{month:02}-{day:02}T{hours_part:02}:{mins_part:02}:{secs_part:02}Z") +} + +fn generate_note_id() -> String { + nanoid::nanoid!(21) +} + +fn yaml_value_to_string(v: &Value) -> String { + match v { + Value::String(s) => s.clone(), + Value::Number(n) => n.to_string(), + Value::Bool(b) => b.to_string(), + other => yaml::to_string(other).unwrap_or_default().trim().to_string(), + } +} +``` + +- [ ] **Step 5.5: Run tests until green** + +```bash +cd apps/desktop-tauri/src-tauri && cargo test --features test-helpers --test vault_frontmatter_test +``` + +Expected: `9 passed`. Common failure modes: +- `serde_yaml_ng` produces booleans as `true`/`false` (lowercase) — matches expected behavior. +- The hand-rolled ISO helper assumes UTC. Acceptable for M3; M4+ can swap to chrono. + +- [ ] **Step 5.6: Commit** + +```bash +git add apps/desktop-tauri/src-tauri/src/vault/frontmatter.rs \ + apps/desktop-tauri/src-tauri/tests/vault_frontmatter_test.rs \ + apps/desktop-tauri/src-tauri/Cargo.toml +git commit -m "m3(vault): frontmatter.rs serde_yaml_ng parse/serialize + Turkish roundtrip" +``` + +--- + +## Task 6: High-level note IO (`vault/notes_io.rs`) + +**Files:** +- Create: `apps/desktop-tauri/src-tauri/src/vault/notes_io.rs` +- Create: `apps/desktop-tauri/src-tauri/tests/vault_notes_io_test.rs` +- Modify: `apps/desktop-tauri/src-tauri/Cargo.toml` (add `[[test]]` entry) + +- [ ] **Step 6.1: Write the failing test** + +Create `apps/desktop-tauri/src-tauri/tests/vault_notes_io_test.rs`: + +```rust +use memry_desktop_tauri_lib::vault::notes_io; +use memry_desktop_tauri_lib::vault::frontmatter::create_frontmatter; +use std::fs; + +fn make_vault() -> tempfile::TempDir { + let dir = tempfile::tempdir().unwrap(); + fs::create_dir_all(dir.path().join("notes")).unwrap(); + dir +} + +#[tokio::test] +async fn write_then_read_roundtrip() { + let vault = make_vault(); + let mut fm = create_frontmatter("Hello", &["work".to_string()]); + fm.id = "fixed-id-1".to_string(); + let written = notes_io::write_note_to_disk( + vault.path(), + "notes/hello.md", + &fm, + "body text", + ) + .await + .unwrap(); + assert_eq!(written.relative_path, "notes/hello.md"); + + let read = notes_io::read_note_from_disk(vault.path(), "notes/hello.md") + .await + .unwrap() + .expect("note must exist"); + assert_eq!(read.parsed.frontmatter.id, "fixed-id-1"); + assert_eq!(read.parsed.frontmatter.title.as_deref(), Some("Hello")); + assert_eq!(read.parsed.content, "body text"); +} + +#[tokio::test] +async fn read_returns_none_for_missing_path() { + let vault = make_vault(); + let result = notes_io::read_note_from_disk(vault.path(), "notes/missing.md") + .await + .unwrap(); + assert!(result.is_none()); +} + +#[tokio::test] +async fn read_auto_repairs_missing_frontmatter_and_writes_back() { + let vault = make_vault(); + let abs = vault.path().join("notes").join("plain.md"); + fs::write(&abs, "no fm here\n").unwrap(); + let read = notes_io::read_note_from_disk(vault.path(), "notes/plain.md") + .await + .unwrap() + .unwrap(); + assert!(read.parsed.was_modified); + let on_disk = fs::read_to_string(&abs).unwrap(); + assert!(on_disk.starts_with("---\n")); + assert!(on_disk.contains(&format!("id: {}", read.parsed.frontmatter.id))); +} + +#[tokio::test] +async fn write_skips_no_op_when_hash_matches() { + let vault = make_vault(); + let mut fm = create_frontmatter("X", &[]); + fm.id = "id-2".to_string(); + let first = notes_io::write_note_to_disk(vault.path(), "notes/x.md", &fm, "same") + .await + .unwrap(); + let second = notes_io::write_note_to_disk(vault.path(), "notes/x.md", &fm, "same") + .await + .unwrap(); + // Hash equality means the second call did NOT bump the file mtime. + assert_eq!(first.content_hash, second.content_hash); +} + +#[tokio::test] +async fn read_rejects_path_traversal() { + let vault = make_vault(); + let err = notes_io::read_note_from_disk(vault.path(), "../escape.md") + .await + .unwrap_err(); + assert!(matches!( + err, + memry_desktop_tauri_lib::error::AppError::PathEscape(_) + )); +} +``` + +- [ ] **Step 6.2: Register the test** + +```toml +[[test]] +name = "vault_notes_io_test" +required-features = ["test-helpers"] +``` + +- [ ] **Step 6.3: Run RED** + +```bash +cd apps/desktop-tauri/src-tauri && cargo test --features test-helpers --test vault_notes_io_test +``` + +Expected: unresolved imports. + +- [ ] **Step 6.4: Implement `vault/notes_io.rs`** + +Replace the stub with: + +```rust +//! High-level note IO. Composes path resolution, atomic write, and +//! frontmatter parse/serialize into the operations Tauri commands +//! call directly. +//! +//! - `read_note_from_disk` returns `None` on missing path. If the +//! on-disk file is missing required frontmatter fields, this writes +//! the repaired version back via atomic_write so subsequent reads +//! do not have to repeat the auto-fill — matches Electron's behavior +//! in `vault/notes.ts::ensureFrontmatter`. +//! - `write_note_to_disk` always serializes via `frontmatter::serialize_note` +//! (which bumps `modified`), then atomic-writes. The returned +//! `NoteOnDisk` includes a SHA-256 content hash so the watcher / +//! sync queue can detect no-op rewrites cheaply. +//! - All paths are vault-relative and forward-slashed. + +use crate::error::AppResult; +use crate::vault::fs as vfs; +use crate::vault::frontmatter::{self, NoteFrontmatter, ParsedNote}; +use crate::vault::paths; +use std::path::Path; + +#[derive(Debug, Clone, serde::Serialize, specta::Type)] +#[serde(rename_all = "camelCase")] +pub struct NoteOnDisk { + pub relative_path: String, + pub content_hash: String, +} + +#[derive(Debug, Clone, serde::Serialize, specta::Type)] +#[serde(rename_all = "camelCase")] +pub struct ReadNoteResult { + pub relative_path: String, + pub raw: String, + pub content_hash: String, + pub parsed: ParsedNote, +} + +pub async fn read_note_from_disk( + vault_root: &Path, + relative_path: &str, +) -> AppResult> { + let abs = paths::resolve_supported(vault_root, relative_path)?; + let raw = match vfs::safe_read(&abs).await? { + Some(s) => s, + None => return Ok(None), + }; + + let parsed = frontmatter::parse_note(&raw, Some(relative_path))?; + + if parsed.was_modified { + let serialized = + frontmatter::serialize_note(&parsed.frontmatter, &parsed.content)?; + vfs::atomic_write(&abs, &serialized).await?; + let hash = vfs::content_hash(&serialized); + return Ok(Some(ReadNoteResult { + relative_path: relative_path.to_string(), + raw: serialized, + content_hash: hash, + parsed, + })); + } + + let hash = vfs::content_hash(&raw); + Ok(Some(ReadNoteResult { + relative_path: relative_path.to_string(), + raw, + content_hash: hash, + parsed, + })) +} + +pub async fn write_note_to_disk( + vault_root: &Path, + relative_path: &str, + frontmatter_in: &NoteFrontmatter, + content: &str, +) -> AppResult { + let abs = paths::resolve_supported(vault_root, relative_path)?; + let serialized = frontmatter::serialize_note(frontmatter_in, content)?; + let new_hash = vfs::content_hash(&serialized); + + if let Some(existing) = vfs::safe_read(&abs).await? { + if vfs::content_hash(&existing) == new_hash { + return Ok(NoteOnDisk { + relative_path: relative_path.to_string(), + content_hash: new_hash, + }); + } + } + + vfs::atomic_write(&abs, &serialized).await?; + Ok(NoteOnDisk { + relative_path: relative_path.to_string(), + content_hash: new_hash, + }) +} + +pub async fn delete_note_from_disk( + vault_root: &Path, + relative_path: &str, +) -> AppResult<()> { + let abs = paths::resolve_supported(vault_root, relative_path)?; + vfs::delete_file(&abs).await +} +``` + +> **Note** — the `write_note_to_disk` no-op short-circuit compares the +> already-serialized form (which includes the bumped `modified` +> timestamp) against the on-disk content. Two back-to-back writes with +> identical input WILL produce identical hashes only if the second +> write happens within the same second AND `serialize_note` is +> deterministic for the input. The test in 6.1 uses a fixed-tag +> frontmatter and writes within the same test invocation, so this +> works in practice. M5 will revisit if real-world callers hit +> false-positive rewrites. + +- [ ] **Step 6.5: Run tests** + +```bash +cd apps/desktop-tauri/src-tauri && cargo test --features test-helpers --test vault_notes_io_test +``` + +Expected: `5 passed`. + +- [ ] **Step 6.6: Commit** + +```bash +git add apps/desktop-tauri/src-tauri/src/vault/notes_io.rs \ + apps/desktop-tauri/src-tauri/tests/vault_notes_io_test.rs \ + apps/desktop-tauri/src-tauri/Cargo.toml +git commit -m "m3(vault): notes_io.rs read_note_from_disk + write_note_to_disk + content-hash skip" +``` + +--- + +## Task 7: Vault preferences (`vault/preferences.rs`) + +**Files:** +- Create: `apps/desktop-tauri/src-tauri/src/vault/preferences.rs` +- Create: `apps/desktop-tauri/src-tauri/tests/vault_preferences_test.rs` +- Modify: `apps/desktop-tauri/src-tauri/Cargo.toml` (add `[[test]]` entry) + +- [ ] **Step 7.1: Write the failing test** + +Create `apps/desktop-tauri/src-tauri/tests/vault_preferences_test.rs`: + +```rust +use memry_desktop_tauri_lib::vault::preferences::{self, VaultConfig, VaultPreferences}; + +fn make_vault() -> tempfile::TempDir { + tempfile::tempdir().unwrap() +} + +#[test] +fn init_creates_dot_memry_with_default_config() { + let vault = make_vault(); + preferences::init_vault(vault.path()).unwrap(); + assert!(vault.path().join(".memry").exists()); + assert!(vault.path().join("notes").exists()); + assert!(vault.path().join("journal").exists()); + assert!(vault.path().join("attachments").exists()); + assert!(vault.path().join(".memry/config.json").exists()); +} + +#[test] +fn init_is_idempotent() { + let vault = make_vault(); + preferences::init_vault(vault.path()).unwrap(); + preferences::init_vault(vault.path()).unwrap(); +} + +#[test] +fn read_config_returns_defaults_when_missing() { + let vault = make_vault(); + let cfg = preferences::read_config(vault.path()).unwrap(); + assert_eq!(cfg.default_note_folder, "notes"); + assert_eq!(cfg.journal_folder, "journal"); + assert_eq!(cfg.attachments_folder, "attachments"); + assert!(cfg.exclude_patterns.contains(&".git".to_string())); +} + +#[test] +fn write_config_round_trips() { + let vault = make_vault(); + preferences::init_vault(vault.path()).unwrap(); + let updated = preferences::update_config(vault.path(), &VaultConfig { + exclude_patterns: vec!["custom".into(), "node_modules".into()], + default_note_folder: "Notes".into(), + journal_folder: "Daily".into(), + attachments_folder: "files".into(), + }) + .unwrap(); + let read = preferences::read_config(vault.path()).unwrap(); + assert_eq!(read.default_note_folder, "Notes"); + assert_eq!(read.journal_folder, "Daily"); + assert_eq!(updated.exclude_patterns, read.exclude_patterns); +} + +#[test] +fn read_preferences_returns_defaults_when_missing() { + let vault = make_vault(); + let prefs = preferences::read_preferences(vault.path()).unwrap(); + assert_eq!(prefs.theme, "system"); + assert_eq!(prefs.font_size, "medium"); +} + +#[test] +fn update_preferences_merges_partial() { + let vault = make_vault(); + preferences::init_vault(vault.path()).unwrap(); + let mut updates = serde_json::Map::new(); + updates.insert("theme".into(), serde_json::Value::String("dark".into())); + let merged = preferences::update_preferences(vault.path(), &updates).unwrap(); + assert_eq!(merged.theme, "dark"); + assert_eq!(merged.font_size, "medium"); // unchanged default +} + +#[test] +fn count_markdown_files_skips_hidden_and_excluded() { + let vault = make_vault(); + preferences::init_vault(vault.path()).unwrap(); + std::fs::write(vault.path().join("notes/a.md"), "x").unwrap(); + std::fs::write(vault.path().join("notes/b.md"), "x").unwrap(); + std::fs::create_dir_all(vault.path().join("node_modules")).unwrap(); + std::fs::write(vault.path().join("node_modules/c.md"), "x").unwrap(); + std::fs::write(vault.path().join("notes/.hidden.md"), "x").unwrap(); + let count = preferences::count_markdown_files( + vault.path(), + &["node_modules".to_string(), ".git".to_string()], + ); + assert_eq!(count, 2); +} + +#[test] +fn turkish_chars_in_config_roundtrip() { + let vault = make_vault(); + preferences::init_vault(vault.path()).unwrap(); + let cfg = VaultConfig { + exclude_patterns: vec![".git".into()], + default_note_folder: "Çalışma".into(), + journal_folder: "Günlük".into(), + attachments_folder: "Ekler".into(), + }; + preferences::update_config(vault.path(), &cfg).unwrap(); + let read = preferences::read_config(vault.path()).unwrap(); + assert_eq!(read.default_note_folder, "Çalışma"); + assert_eq!(read.journal_folder, "Günlük"); +} +``` + +- [ ] **Step 7.2: Register the test** + +```toml +[[test]] +name = "vault_preferences_test" +required-features = ["test-helpers"] +``` + +- [ ] **Step 7.3: Run RED** + +```bash +cd apps/desktop-tauri/src-tauri && cargo test --features test-helpers --test vault_preferences_test +``` + +- [ ] **Step 7.4: Implement `vault/preferences.rs`** + +Replace the stub with: + +```rust +//! Per-vault JSON config + UI preferences. +//! +//! Layout matches Electron's vault format: +//! +//! ```text +//! / +//! ├── .memry/ +//! │ └── config.json { excludePatterns, defaultNoteFolder, journalFolder, +//! │ attachmentsFolder, preferences: { theme, ... } } +//! ├── notes/ +//! ├── journal/ +//! └── attachments/ +//! ``` +//! +//! `init_vault` creates the directory tree and writes the default +//! config if it does not exist (idempotent). `read_config` and +//! `read_preferences` return defaults when the file is missing or +//! corrupt — they never error on a brand-new vault. `update_*` +//! merges the partial input into the existing config and writes it +//! atomically. + +use crate::error::{AppError, AppResult}; +use crate::vault::fs as vfs; +use serde_json::Map; +use std::fs; +use std::path::{Path, PathBuf}; + +const MEMRY_DIR: &str = ".memry"; +const CONFIG_FILE: &str = "config.json"; + +const VAULT_FOLDERS: &[&str] = &[ + "notes", + "journal", + "attachments", + "attachments/images", + "attachments/files", +]; + +#[derive(Debug, Clone, serde::Serialize, serde::Deserialize, specta::Type)] +#[serde(rename_all = "camelCase")] +pub struct VaultConfig { + pub exclude_patterns: Vec, + pub default_note_folder: String, + pub journal_folder: String, + pub attachments_folder: String, +} + +impl Default for VaultConfig { + fn default() -> Self { + Self { + exclude_patterns: vec![ + ".git".into(), + "node_modules".into(), + ".trash".into(), + ], + default_note_folder: "notes".into(), + journal_folder: "journal".into(), + attachments_folder: "attachments".into(), + } + } +} + +#[derive(Debug, Clone, serde::Serialize, serde::Deserialize, specta::Type)] +#[serde(rename_all = "camelCase")] +pub struct EditorPreferences { + pub width: String, + pub spell_check: bool, + pub auto_save_delay: u32, + pub show_word_count: bool, + pub toolbar_mode: String, +} + +impl Default for EditorPreferences { + fn default() -> Self { + Self { + width: "medium".into(), + spell_check: true, + auto_save_delay: 1000, + show_word_count: true, + toolbar_mode: "floating".into(), + } + } +} + +#[derive(Debug, Clone, serde::Serialize, serde::Deserialize, specta::Type)] +#[serde(rename_all = "camelCase")] +pub struct VaultPreferences { + pub theme: String, + pub font_size: String, + pub font_family: String, + pub accent_color: String, + pub language: String, + pub create_in_selected_folder: bool, + pub editor: EditorPreferences, +} + +impl Default for VaultPreferences { + fn default() -> Self { + Self { + theme: "system".into(), + font_size: "medium".into(), + font_family: "system".into(), + accent_color: "#2563eb".into(), + language: "en".into(), + create_in_selected_folder: true, + editor: EditorPreferences::default(), + } + } +} + +pub fn memry_dir(vault_path: &Path) -> PathBuf { + vault_path.join(MEMRY_DIR) +} + +pub fn config_path(vault_path: &Path) -> PathBuf { + memry_dir(vault_path).join(CONFIG_FILE) +} + +pub fn is_initialized(vault_path: &Path) -> bool { + memry_dir(vault_path).exists() +} + +pub fn init_vault(vault_path: &Path) -> AppResult<()> { + fs::create_dir_all(memry_dir(vault_path))?; + for folder in VAULT_FOLDERS { + fs::create_dir_all(vault_path.join(folder))?; + } + let cfg_path = config_path(vault_path); + if !cfg_path.exists() { + let default = build_initial_config_blob(); + fs::write(&cfg_path, serde_json::to_string_pretty(&default)?)?; + } + Ok(()) +} + +fn build_initial_config_blob() -> serde_json::Value { + serde_json::json!({ + "excludePatterns": VaultConfig::default().exclude_patterns, + "defaultNoteFolder": VaultConfig::default().default_note_folder, + "journalFolder": VaultConfig::default().journal_folder, + "attachmentsFolder": VaultConfig::default().attachments_folder, + "preferences": serde_json::to_value(VaultPreferences::default()).unwrap(), + }) +} + +fn read_config_blob(vault_path: &Path) -> AppResult { + let path = config_path(vault_path); + if !path.exists() { + return Ok(build_initial_config_blob()); + } + let raw = fs::read_to_string(&path)?; + let parsed: serde_json::Value = + serde_json::from_str(&raw).unwrap_or_else(|_| build_initial_config_blob()); + Ok(parsed) +} + +pub fn read_config(vault_path: &Path) -> AppResult { + let blob = read_config_blob(vault_path)?; + Ok(VaultConfig { + exclude_patterns: blob + .get("excludePatterns") + .and_then(|v| v.as_array()) + .map(|arr| { + arr.iter() + .filter_map(|v| v.as_str().map(String::from)) + .collect() + }) + .unwrap_or_else(|| VaultConfig::default().exclude_patterns), + default_note_folder: blob + .get("defaultNoteFolder") + .and_then(|v| v.as_str()) + .map(String::from) + .unwrap_or_else(|| VaultConfig::default().default_note_folder), + journal_folder: blob + .get("journalFolder") + .and_then(|v| v.as_str()) + .map(String::from) + .unwrap_or_else(|| VaultConfig::default().journal_folder), + attachments_folder: blob + .get("attachmentsFolder") + .and_then(|v| v.as_str()) + .map(String::from) + .unwrap_or_else(|| VaultConfig::default().attachments_folder), + }) +} + +pub fn update_config(vault_path: &Path, updates: &VaultConfig) -> AppResult { + let mut blob = read_config_blob(vault_path)?; + let obj = blob + .as_object_mut() + .ok_or_else(|| AppError::Validation("config.json is not an object".into()))?; + obj.insert( + "excludePatterns".into(), + serde_json::to_value(&updates.exclude_patterns)?, + ); + obj.insert( + "defaultNoteFolder".into(), + serde_json::Value::String(updates.default_note_folder.clone()), + ); + obj.insert( + "journalFolder".into(), + serde_json::Value::String(updates.journal_folder.clone()), + ); + obj.insert( + "attachmentsFolder".into(), + serde_json::Value::String(updates.attachments_folder.clone()), + ); + write_config_blob_atomic(vault_path, &blob)?; + Ok(updates.clone()) +} + +pub fn read_preferences(vault_path: &Path) -> AppResult { + let blob = read_config_blob(vault_path)?; + let prefs_val = blob + .get("preferences") + .cloned() + .unwrap_or_else(|| serde_json::to_value(VaultPreferences::default()).unwrap()); + Ok(serde_json::from_value(prefs_val).unwrap_or_default()) +} + +pub fn update_preferences( + vault_path: &Path, + partial: &Map, +) -> AppResult { + let mut blob = read_config_blob(vault_path)?; + let obj = blob + .as_object_mut() + .ok_or_else(|| AppError::Validation("config.json is not an object".into()))?; + let mut current = obj + .get("preferences") + .cloned() + .unwrap_or_else(|| serde_json::to_value(VaultPreferences::default()).unwrap()); + if let Some(map) = current.as_object_mut() { + for (k, v) in partial { + map.insert(k.clone(), v.clone()); + } + } + obj.insert("preferences".into(), current); + write_config_blob_atomic(vault_path, &blob)?; + read_preferences(vault_path) +} + +fn write_config_blob_atomic( + vault_path: &Path, + blob: &serde_json::Value, +) -> AppResult<()> { + let path = config_path(vault_path); + let serialized = serde_json::to_string_pretty(blob)?; + let runtime = tokio::runtime::Handle::try_current(); + match runtime { + Ok(handle) => { + let path = path.clone(); + handle.block_on(vfs::atomic_write(&path, &serialized))?; + } + Err(_) => { + // Outside Tokio context (e.g. setup callbacks). Fall back to + // sync write — config is small (<10KB) so torn writes are + // unlikely. + fs::write(&path, serialized)?; + } + } + Ok(()) +} + +pub fn count_markdown_files(vault_path: &Path, exclude: &[String]) -> i64 { + let mut count: i64 = 0; + let mut stack = vec![vault_path.to_path_buf()]; + while let Some(dir) = stack.pop() { + let entries = match fs::read_dir(&dir) { + Ok(e) => e, + Err(_) => continue, + }; + for entry in entries.flatten() { + let name = entry.file_name(); + let name_str = name.to_string_lossy(); + if name_str.starts_with('.') { + continue; + } + if exclude.iter().any(|p| p == &*name_str) { + continue; + } + let path = entry.path(); + if path.is_dir() { + stack.push(path); + } else if path.is_file() && crate::vault::paths::is_markdown(&path) { + count += 1; + } + } + } + count +} + +pub fn vault_name(vault_path: &Path) -> String { + vault_path + .file_name() + .and_then(|s| s.to_str()) + .unwrap_or("vault") + .to_string() +} +``` + +- [ ] **Step 7.5: Run tests** + +```bash +cd apps/desktop-tauri/src-tauri && cargo test --features test-helpers --test vault_preferences_test +``` + +Expected: `8 passed`. + +- [ ] **Step 7.6: Commit** + +```bash +git add apps/desktop-tauri/src-tauri/src/vault/preferences.rs \ + apps/desktop-tauri/src-tauri/tests/vault_preferences_test.rs \ + apps/desktop-tauri/src-tauri/Cargo.toml +git commit -m "m3(vault): preferences.rs config.json + theme/editor preferences with Turkish roundtrip" +``` + +--- + +## Task 8: Vault registry — multi-vault list (`vault/registry.rs`) + +**Files:** +- Create: `apps/desktop-tauri/src-tauri/src/vault/registry.rs` +- Create: `apps/desktop-tauri/src-tauri/tests/vault_registry_test.rs` +- Modify: `apps/desktop-tauri/src-tauri/Cargo.toml` (add `[[test]]` entry) + +- [ ] **Step 8.1: Write the failing test** + +Create `apps/desktop-tauri/src-tauri/tests/vault_registry_test.rs`: + +```rust +use memry_desktop_tauri_lib::vault::registry::{self, VaultInfo, VaultRegistry}; + +fn registry_path(dir: &tempfile::TempDir) -> std::path::PathBuf { + dir.path().join("vaults.json") +} + +fn make_info(path: &std::path::Path, name: &str, is_default: bool) -> VaultInfo { + VaultInfo { + path: path.to_string_lossy().into_owned(), + name: name.into(), + note_count: 0, + task_count: 0, + last_opened: "2026-04-26T00:00:00Z".into(), + is_default, + } +} + +#[test] +fn empty_registry_when_file_missing() { + let dir = tempfile::tempdir().unwrap(); + let reg = VaultRegistry::load(®istry_path(&dir)).unwrap(); + assert!(reg.vaults.is_empty()); + assert!(reg.current.is_none()); +} + +#[test] +fn upsert_then_persist_then_reload() { + let dir = tempfile::tempdir().unwrap(); + let path = registry_path(&dir); + let mut reg = VaultRegistry::load(&path).unwrap(); + + let v_dir = tempfile::tempdir().unwrap(); + reg.upsert(make_info(v_dir.path(), "Primary", true)); + reg.set_current(Some(v_dir.path().to_string_lossy().into_owned())); + reg.save(&path).unwrap(); + + let reloaded = VaultRegistry::load(&path).unwrap(); + assert_eq!(reloaded.vaults.len(), 1); + assert_eq!(reloaded.vaults[0].name, "Primary"); + assert_eq!(reloaded.current.as_deref(), Some(v_dir.path().to_string_lossy().as_ref())); +} + +#[test] +fn upsert_replaces_by_path_not_duplicates() { + let dir = tempfile::tempdir().unwrap(); + let v_dir = tempfile::tempdir().unwrap(); + let mut reg = VaultRegistry::load(®istry_path(&dir)).unwrap(); + reg.upsert(make_info(v_dir.path(), "First", true)); + reg.upsert(make_info(v_dir.path(), "Renamed", false)); + assert_eq!(reg.vaults.len(), 1); + assert_eq!(reg.vaults[0].name, "Renamed"); + assert!(!reg.vaults[0].is_default); +} + +#[test] +fn remove_drops_vault_and_clears_current_if_match() { + let dir = tempfile::tempdir().unwrap(); + let v1 = tempfile::tempdir().unwrap(); + let v2 = tempfile::tempdir().unwrap(); + let mut reg = VaultRegistry::load(®istry_path(&dir)).unwrap(); + reg.upsert(make_info(v1.path(), "v1", true)); + reg.upsert(make_info(v2.path(), "v2", false)); + reg.set_current(Some(v1.path().to_string_lossy().into_owned())); + + reg.remove(&v1.path().to_string_lossy()); + assert_eq!(reg.vaults.len(), 1); + assert_eq!(reg.vaults[0].name, "v2"); + assert!(reg.current.is_none()); +} + +#[test] +fn touch_updates_last_opened() { + let dir = tempfile::tempdir().unwrap(); + let v = tempfile::tempdir().unwrap(); + let mut reg = VaultRegistry::load(®istry_path(&dir)).unwrap(); + reg.upsert(make_info(v.path(), "v", true)); + let before = reg.vaults[0].last_opened.clone(); + std::thread::sleep(std::time::Duration::from_millis(10)); + reg.touch(&v.path().to_string_lossy()); + let after = reg.vaults[0].last_opened.clone(); + assert_ne!(before, after, "touch should bump last_opened"); +} + +#[test] +fn corrupt_file_falls_back_to_empty_registry() { + let dir = tempfile::tempdir().unwrap(); + let path = registry_path(&dir); + std::fs::write(&path, "{not valid json}").unwrap(); + let reg = VaultRegistry::load(&path).unwrap(); + assert!(reg.vaults.is_empty()); + assert!(reg.current.is_none()); +} +``` + +- [ ] **Step 8.2: Register the test** + +```toml +[[test]] +name = "vault_registry_test" +required-features = ["test-helpers"] +``` + +- [ ] **Step 8.3: Run RED** + +```bash +cd apps/desktop-tauri/src-tauri && cargo test --features test-helpers --test vault_registry_test +``` + +- [ ] **Step 8.4: Implement `vault/registry.rs`** + +Replace the stub with: + +```rust +//! Multi-vault registry persisted at +//! `/memry-{device}/vaults.json` (per-device, matches the +//! M2 DB path scheme). Holds the list of known vaults plus the +//! "current" vault path. `lib.rs::run` loads it at boot, `vault::state` +//! mutates it, and `vault_*` commands read it for the renderer. +//! +//! Persistence is best-effort sync JSON: the file is small (<2KB +//! typical) and only written on user actions (open/switch/remove). + +use crate::error::{AppError, AppResult}; +use std::fs; +use std::path::Path; + +#[derive(Debug, Clone, serde::Serialize, serde::Deserialize, specta::Type)] +#[serde(rename_all = "camelCase")] +pub struct VaultInfo { + pub path: String, + pub name: String, + pub note_count: i64, + pub task_count: i64, + pub last_opened: String, + pub is_default: bool, +} + +#[derive(Debug, Clone, Default, serde::Serialize, serde::Deserialize, specta::Type)] +#[serde(rename_all = "camelCase")] +pub struct VaultRegistry { + #[serde(default)] + pub vaults: Vec, + #[serde(default)] + pub current: Option, +} + +impl VaultRegistry { + pub fn load(path: &Path) -> AppResult { + if !path.exists() { + return Ok(Self::default()); + } + let raw = fs::read_to_string(path)?; + let parsed: Self = serde_json::from_str(&raw).unwrap_or_default(); + Ok(parsed) + } + + pub fn save(&self, path: &Path) -> AppResult<()> { + if let Some(parent) = path.parent() { + fs::create_dir_all(parent)?; + } + let raw = serde_json::to_string_pretty(self)?; + fs::write(path, raw)?; + Ok(()) + } + + pub fn find(&self, vault_path: &str) -> Option<&VaultInfo> { + self.vaults.iter().find(|v| v.path == vault_path) + } + + pub fn upsert(&mut self, info: VaultInfo) { + if let Some(slot) = self.vaults.iter_mut().find(|v| v.path == info.path) { + *slot = info; + } else { + self.vaults.push(info); + } + } + + pub fn remove(&mut self, vault_path: &str) { + self.vaults.retain(|v| v.path != vault_path); + if self.current.as_deref() == Some(vault_path) { + self.current = None; + } + } + + pub fn set_current(&mut self, current: Option) { + self.current = current; + } + + pub fn touch(&mut self, vault_path: &str) { + let now = current_iso(); + if let Some(slot) = self.vaults.iter_mut().find(|v| v.path == vault_path) { + slot.last_opened = now; + } + } +} + +fn current_iso() -> String { + use std::time::{SystemTime, UNIX_EPOCH}; + let secs = SystemTime::now() + .duration_since(UNIX_EPOCH) + .map(|d| d.as_secs()) + .unwrap_or(0); + crate::vault::frontmatter_iso(secs) +} + +pub fn registry_path() -> AppResult { + let device = std::env::var("MEMRY_DEVICE").unwrap_or_else(|_| "default".to_string()); + let project_dirs = directories::ProjectDirs::from("com", "memry", "memry") + .ok_or_else(|| AppError::Internal("could not determine OS project dirs".into()))?; + Ok(project_dirs + .data_dir() + .join(format!("memry-{device}")) + .join("vaults.json")) +} +``` + +- [ ] **Step 8.5: Add a tiny ISO helper alias in `frontmatter.rs`** + +Re-open `apps/desktop-tauri/src-tauri/src/vault/frontmatter.rs`. Make the existing `unix_secs_to_iso` function `pub(crate)` and add a re-export at the module path used by `registry.rs`: + +In `frontmatter.rs`, change: + +```rust +fn unix_secs_to_iso(secs: u64) -> String { +``` + +to: + +```rust +pub(crate) fn unix_secs_to_iso(secs: u64) -> String { +``` + +Then in `apps/desktop-tauri/src-tauri/src/vault/mod.rs` add: + +```rust +pub(crate) fn frontmatter_iso(secs: u64) -> String { + frontmatter::unix_secs_to_iso(secs) +} +``` + +- [ ] **Step 8.6: Run tests** + +```bash +cd apps/desktop-tauri/src-tauri && cargo test --features test-helpers --test vault_registry_test +``` + +Expected: `6 passed`. + +- [ ] **Step 8.7: Commit** + +```bash +git add apps/desktop-tauri/src-tauri/src/vault/registry.rs \ + apps/desktop-tauri/src-tauri/src/vault/mod.rs \ + apps/desktop-tauri/src-tauri/src/vault/frontmatter.rs \ + apps/desktop-tauri/src-tauri/tests/vault_registry_test.rs \ + apps/desktop-tauri/src-tauri/Cargo.toml +git commit -m "m3(vault): registry.rs multi-vault list at /memry-{device}/vaults.json" +``` + +--- + +## Task 9: Vault runtime state + AppState wiring (`vault/state.rs`) + +**Files:** +- Create: `apps/desktop-tauri/src-tauri/src/vault/state.rs` +- Modify: `apps/desktop-tauri/src-tauri/src/vault/mod.rs` (uncomment re-exports now that types exist) +- Modify: `apps/desktop-tauri/src-tauri/src/app_state.rs` +- Modify: `apps/desktop-tauri/src-tauri/src/lib.rs` + +- [ ] **Step 9.1: Implement `vault/state.rs`** + +Replace the stub with: + +```rust +//! Runtime state for the vault layer. +//! +//! `VaultRuntime` owns: +//! - the current vault path (None when no vault is open) +//! - status flags (is_indexing, index_progress, error) +//! - the in-memory registry handle (loaded from disk at boot) +//! - the active `notify` watcher handle (started on open, stopped on +//! close) +//! +//! All fields are wrapped in `parking_lot::Mutex` (or `std::sync::Mutex` +//! — we use std for now, Tokio doesn't bind these). Tauri commands +//! lock briefly per call. The watcher itself runs on its own thread +//! managed by `notify`; the `Drop` impl on the watcher handle cleans +//! it up when the option is replaced. + +use crate::error::{AppError, AppResult}; +use crate::vault::registry::{VaultRegistry, registry_path}; +use std::path::PathBuf; +use std::sync::Mutex; + +#[derive(Debug, Clone, Default, serde::Serialize, serde::Deserialize, specta::Type)] +#[serde(rename_all = "camelCase")] +pub struct VaultStatus { + pub is_open: bool, + pub path: Option, + pub is_indexing: bool, + pub index_progress: u8, + pub error: Option, +} + +pub struct VaultRuntime { + inner: Mutex, + pub watcher_slot: Mutex>, + registry_path: PathBuf, +} + +struct RuntimeInner { + current: Option, + is_indexing: bool, + index_progress: u8, + error: Option, + registry: VaultRegistry, +} + +impl VaultRuntime { + pub fn boot() -> AppResult { + let registry_path = registry_path()?; + let registry = VaultRegistry::load(®istry_path).unwrap_or_default(); + Ok(Self { + inner: Mutex::new(RuntimeInner { + current: registry.current.as_ref().map(PathBuf::from), + is_indexing: false, + index_progress: 0, + error: None, + registry, + }), + watcher_slot: Mutex::new(None), + registry_path, + }) + } + + pub fn status(&self) -> VaultStatus { + let g = self.inner.lock().unwrap_or_else(|p| p.into_inner()); + VaultStatus { + is_open: g.current.is_some(), + path: g + .current + .as_ref() + .map(|p| p.to_string_lossy().into_owned()), + is_indexing: g.is_indexing, + index_progress: g.index_progress, + error: g.error.clone(), + } + } + + pub fn current_path(&self) -> Option { + let g = self.inner.lock().unwrap_or_else(|p| p.into_inner()); + g.current.clone() + } + + pub fn registry_snapshot(&self) -> VaultRegistry { + let g = self.inner.lock().unwrap_or_else(|p| p.into_inner()); + g.registry.clone() + } + + pub fn set_current(&self, path: Option) -> AppResult<()> { + { + let mut g = self.inner.lock().unwrap_or_else(|p| p.into_inner()); + g.current = path.clone(); + g.error = None; + g.registry + .set_current(path.as_ref().map(|p| p.to_string_lossy().into_owned())); + g.registry.save(&self.registry_path)?; + } + Ok(()) + } + + pub fn upsert_registry(&self, info: crate::vault::registry::VaultInfo) -> AppResult<()> { + let mut g = self.inner.lock().unwrap_or_else(|p| p.into_inner()); + g.registry.upsert(info); + g.registry.save(&self.registry_path) + } + + pub fn remove_from_registry(&self, vault_path: &str) -> AppResult<()> { + let mut g = self.inner.lock().unwrap_or_else(|p| p.into_inner()); + g.registry.remove(vault_path); + if g.current.as_deref().map(|p| p.to_string_lossy().into_owned()) + == Some(vault_path.to_string()) + { + g.current = None; + } + g.registry.save(&self.registry_path) + } + + pub fn touch_registry(&self, vault_path: &str) -> AppResult<()> { + let mut g = self.inner.lock().unwrap_or_else(|p| p.into_inner()); + g.registry.touch(vault_path); + g.registry.save(&self.registry_path) + } + + pub fn set_indexing(&self, indexing: bool, progress: u8) { + let mut g = self.inner.lock().unwrap_or_else(|p| p.into_inner()); + g.is_indexing = indexing; + g.index_progress = progress; + } + + pub fn set_error(&self, error: Option) { + let mut g = self.inner.lock().unwrap_or_else(|p| p.into_inner()); + g.error = error; + } + + pub fn require_current(&self) -> AppResult { + self.current_path() + .ok_or_else(|| AppError::Vault("no vault is open".into())) + } +} +``` + +- [ ] **Step 9.2: Re-enable re-exports in `vault/mod.rs`** + +Replace the commented-out block with: + +```rust +pub use frontmatter::{NoteFrontmatter, ParsedNote}; +pub use notes_io::{NoteOnDisk, ReadNoteResult}; +pub use preferences::{VaultConfig, VaultPreferences}; +pub use registry::{VaultInfo, VaultRegistry}; +pub use state::{VaultRuntime, VaultStatus}; +``` + +- [ ] **Step 9.3: Add `vault: Arc` to `AppState`** + +Open `apps/desktop-tauri/src-tauri/src/app_state.rs` and replace the contents with: + +```rust +//! Global runtime state shared across commands. + +use crate::db::Db; +use crate::vault::VaultRuntime; +use std::sync::Arc; + +pub struct AppState { + pub db: Db, + pub vault: Arc, +} + +impl AppState { + pub fn new(db: Db, vault: Arc) -> Self { + Self { db, vault } + } +} +``` + +- [ ] **Step 9.4: Wire `VaultRuntime::boot()` into `lib.rs::run`** + +Open `apps/desktop-tauri/src-tauri/src/lib.rs`. Replace the `init_app_state` function with: + +```rust +fn init_app_state() -> AppResult { + let db_path = resolve_db_path()?; + let db = Db::open(db_path)?; + let vault = std::sync::Arc::new(crate::vault::VaultRuntime::boot()?); + Ok(AppState::new(db, vault)) +} +``` + +- [ ] **Step 9.5: Verify cargo check + existing tests still pass** + +```bash +cd apps/desktop-tauri/src-tauri && cargo check && \ + cargo test --features test-helpers --tests +``` + +Expected: every previously-green test stays green. `vault_state` does not have its own integration test (state is exercised by Task 11's command tests + the runtime smoke). + +- [ ] **Step 9.6: Commit** + +```bash +git add apps/desktop-tauri/src-tauri/src/vault/state.rs \ + apps/desktop-tauri/src-tauri/src/vault/mod.rs \ + apps/desktop-tauri/src-tauri/src/app_state.rs \ + apps/desktop-tauri/src-tauri/src/lib.rs +git commit -m "m3(vault): VaultRuntime + AppState extension + boot wiring" +``` + +--- + +## Task 10: File watcher with debounce (`vault/watcher.rs`) + +**Files:** +- Create: `apps/desktop-tauri/src-tauri/src/vault/watcher.rs` +- Create: `apps/desktop-tauri/src-tauri/tests/vault_watcher_test.rs` +- Modify: `apps/desktop-tauri/src-tauri/Cargo.toml` (add `[[test]]` entry) + +- [ ] **Step 10.1: Write the failing test** + +Create `apps/desktop-tauri/src-tauri/tests/vault_watcher_test.rs`: + +```rust +use memry_desktop_tauri_lib::vault::watcher::{self, VaultEvent, VaultEventKind}; +use std::fs; +use std::time::Duration; +use tokio::sync::mpsc; +use tokio::time::timeout; + +fn make_vault() -> tempfile::TempDir { + let dir = tempfile::tempdir().unwrap(); + fs::create_dir_all(dir.path().join("notes")).unwrap(); + dir +} + +#[tokio::test(flavor = "multi_thread")] +async fn detects_new_file_within_debounce_window() { + let vault = make_vault(); + let (tx, mut rx) = mpsc::unbounded_channel(); + let handle = watcher::start(vault.path(), tx).unwrap(); + tokio::time::sleep(Duration::from_millis(100)).await; + + fs::write(vault.path().join("notes/new.md"), "hello").unwrap(); + + let event: VaultEvent = timeout(Duration::from_secs(2), rx.recv()) + .await + .expect("timed out waiting for vault-changed") + .expect("channel closed"); + + assert!(event.relative_path.ends_with("new.md")); + assert!(matches!(event.kind, VaultEventKind::Created | VaultEventKind::Modified)); + + drop(handle); +} + +#[tokio::test(flavor = "multi_thread")] +async fn debounces_rapid_writes_to_same_file() { + let vault = make_vault(); + let (tx, mut rx) = mpsc::unbounded_channel(); + let handle = watcher::start(vault.path(), tx).unwrap(); + tokio::time::sleep(Duration::from_millis(100)).await; + + let path = vault.path().join("notes/burst.md"); + for i in 0..5 { + fs::write(&path, format!("v{i}")).unwrap(); + tokio::time::sleep(Duration::from_millis(20)).await; + } + + let mut count = 0; + let mut total = Duration::from_millis(0); + while total < Duration::from_secs(2) { + match timeout(Duration::from_millis(400), rx.recv()).await { + Ok(Some(_)) => count += 1, + _ => break, + } + total += Duration::from_millis(400); + } + assert!(count >= 1, "should fire at least once"); + assert!(count <= 3, "debounce should coalesce rapid writes (got {count})"); + + drop(handle); +} + +#[tokio::test(flavor = "multi_thread")] +async fn ignores_dot_memry_writes() { + let vault = make_vault(); + fs::create_dir_all(vault.path().join(".memry")).unwrap(); + let (tx, mut rx) = mpsc::unbounded_channel(); + let handle = watcher::start(vault.path(), tx).unwrap(); + tokio::time::sleep(Duration::from_millis(100)).await; + + fs::write(vault.path().join(".memry/data.db"), "x").unwrap(); + + let event = timeout(Duration::from_millis(500), rx.recv()).await; + assert!(event.is_err(), "must not emit for .memry/ writes"); + + drop(handle); +} + +#[tokio::test(flavor = "multi_thread")] +async fn detects_deletion() { + let vault = make_vault(); + let path = vault.path().join("notes/del.md"); + fs::write(&path, "x").unwrap(); + let (tx, mut rx) = mpsc::unbounded_channel(); + let handle = watcher::start(vault.path(), tx).unwrap(); + tokio::time::sleep(Duration::from_millis(100)).await; + + fs::remove_file(&path).unwrap(); + + let mut saw_delete = false; + let deadline = std::time::Instant::now() + Duration::from_secs(2); + while std::time::Instant::now() < deadline { + match timeout(Duration::from_millis(300), rx.recv()).await { + Ok(Some(ev)) if matches!(ev.kind, VaultEventKind::Deleted) => { + saw_delete = true; + break; + } + Ok(Some(_)) => continue, + _ => break, + } + } + assert!(saw_delete, "expected a Deleted event"); + + drop(handle); +} +``` + +- [ ] **Step 10.2: Register the test** + +```toml +[[test]] +name = "vault_watcher_test" +required-features = ["test-helpers"] +``` + +- [ ] **Step 10.3: Implement `vault/watcher.rs`** + +Replace the stub with: + +```rust +//! `notify` filesystem watcher with path-keyed debounce. +//! +//! - `start(vault_root, sender)` registers a recursive recommended +//! watcher rooted at `vault_root` and returns an opaque handle that +//! stops the watcher when dropped. +//! - Raw `notify` events are filtered: hidden basenames (`.foo`), +//! anything inside `.memry/`, and unsupported extensions are +//! ignored before queuing. +//! - A path-keyed debounce coalesces rapid writes within 150ms per +//! file. Each file gets its own pending timer. +//! - The output channel emits `VaultEvent { relative_path, kind }` +//! where `kind` is `Created`, `Modified`, or `Deleted`. + +use crate::error::{AppError, AppResult}; +use crate::vault::paths; +use notify::{event::ModifyKind, EventKind, RecommendedWatcher, RecursiveMode, Watcher}; +use std::collections::HashMap; +use std::path::{Path, PathBuf}; +use std::sync::{Arc, Mutex}; +use std::time::Duration; +use tokio::sync::mpsc::UnboundedSender; +use tokio::task::JoinHandle; + +const DEBOUNCE_MS: u64 = 150; + +#[derive(Debug, Clone, serde::Serialize, specta::Type)] +#[serde(rename_all = "camelCase")] +pub struct VaultEvent { + pub relative_path: String, + pub kind: VaultEventKind, +} + +#[derive(Debug, Clone, Copy, serde::Serialize, specta::Type)] +#[serde(rename_all = "lowercase")] +pub enum VaultEventKind { + Created, + Modified, + Deleted, +} + +pub struct WatcherHandle { + _watcher: RecommendedWatcher, + _scheduler: JoinHandle<()>, + cancel: Arc, +} + +impl Drop for WatcherHandle { + fn drop(&mut self) { + self.cancel + .store(true, std::sync::atomic::Ordering::Relaxed); + } +} + +#[derive(Default)] +struct PendingMap { + pending: HashMap, +} + +struct PendingEntry { + last_event: VaultEventKind, + deadline: std::time::Instant, +} + +pub fn start( + vault_root: &Path, + out: UnboundedSender, +) -> AppResult { + let canonical_root = dunce::canonicalize(vault_root)?; + let pending = Arc::new(Mutex::new(PendingMap::default())); + let cancel = Arc::new(std::sync::atomic::AtomicBool::new(false)); + let (raw_tx, mut raw_rx) = + tokio::sync::mpsc::unbounded_channel::(); + + // notify callback runs on its own thread; bridge into the Tokio + // channel so the rest of the pipeline is async. + let cb_root = canonical_root.clone(); + let raw_tx_for_cb = raw_tx.clone(); + let mut watcher = notify::recommended_watcher(move |res: notify::Result| { + if let Ok(event) = res { + // Filter inside the callback so the bounded channel + // doesn't fill up with `.memry/` chatter on a busy DB. + if event.paths.iter().all(|p| should_ignore(&cb_root, p)) { + return; + } + let _ = raw_tx_for_cb.send(event); + } + })?; + drop(raw_tx); + + watcher.watch(&canonical_root, RecursiveMode::Recursive)?; + + // Drain raw events into the pending map, bumping the deadline + // every time we see another event for the same path. + let pending_drain = pending.clone(); + let cancel_drain = cancel.clone(); + let root_for_drain = canonical_root.clone(); + let _drain: JoinHandle<()> = tokio::spawn(async move { + while let Some(event) = raw_rx.recv().await { + if cancel_drain.load(std::sync::atomic::Ordering::Relaxed) { + break; + } + let kind = classify(&event.kind); + for path in event.paths { + if should_ignore(&root_for_drain, &path) { + continue; + } + let entry = PendingEntry { + last_event: kind, + deadline: std::time::Instant::now() + + Duration::from_millis(DEBOUNCE_MS), + }; + pending_drain + .lock() + .unwrap_or_else(|p| p.into_inner()) + .pending + .insert(path, entry); + } + } + }); + + // Periodically scan the pending map for entries whose deadline + // has passed and emit them. + let pending_emit = pending.clone(); + let cancel_emit = cancel.clone(); + let root_for_emit = canonical_root.clone(); + let scheduler: JoinHandle<()> = tokio::spawn(async move { + let tick = Duration::from_millis(50); + loop { + if cancel_emit.load(std::sync::atomic::Ordering::Relaxed) { + break; + } + tokio::time::sleep(tick).await; + let now = std::time::Instant::now(); + let ready: Vec<(PathBuf, VaultEventKind)> = { + let mut g = pending_emit + .lock() + .unwrap_or_else(|p| p.into_inner()); + let mut ready = Vec::new(); + g.pending.retain(|path, entry| { + if entry.deadline <= now { + ready.push((path.clone(), entry.last_event)); + false + } else { + true + } + }); + ready + }; + for (path, kind) in ready { + if let Some(rel) = + paths::to_relative_path(&root_for_emit, &path) + { + let _ = out.send(VaultEvent { + relative_path: rel, + kind, + }); + } else if matches!(kind, VaultEventKind::Deleted) { + // Deleted file canonicalize fails; fall back to + // string strip. + if let Ok(stripped) = path.strip_prefix(&root_for_emit) { + let rel = + stripped.to_string_lossy().replace('\\', "/"); + let _ = out.send(VaultEvent { + relative_path: rel, + kind, + }); + } + } + } + } + }); + + Ok(WatcherHandle { + _watcher: watcher, + _scheduler: scheduler, + cancel, + }) +} + +fn should_ignore(root: &Path, path: &Path) -> bool { + let rel = match path.strip_prefix(root) { + Ok(r) => r, + Err(_) => return true, + }; + let mut comps = rel.components(); + while let Some(c) = comps.next() { + if let std::path::Component::Normal(seg) = c { + let s = seg.to_string_lossy(); + if s.starts_with('.') { + return true; + } + } + } + if !path.is_dir() { + let lower = path + .extension() + .and_then(|e| e.to_str()) + .map(|s| s.to_lowercase()) + .unwrap_or_default(); + if lower.is_empty() { + return true; + } + let supported = matches!( + lower.as_str(), + "md" | "markdown" | "png" | "jpg" | "jpeg" | "gif" | "webp" | + "svg" | "pdf" | "mp3" | "wav" | "m4a" | "ogg" | "mp4" | "mov" | "webm" + ); + return !supported; + } + false +} + +fn classify(kind: &EventKind) -> VaultEventKind { + match kind { + EventKind::Create(_) => VaultEventKind::Created, + EventKind::Modify(ModifyKind::Name(_)) => VaultEventKind::Modified, + EventKind::Modify(_) => VaultEventKind::Modified, + EventKind::Remove(_) => VaultEventKind::Deleted, + _ => VaultEventKind::Modified, + } +} +``` + +- [ ] **Step 10.4: Verify cargo check before running watcher tests** + +```bash +cd apps/desktop-tauri/src-tauri && cargo check +``` + +Expected: pass. The watcher module is self-contained except for `paths`. + +- [ ] **Step 10.5: Run watcher tests (slow — ~10s)** + +```bash +cd apps/desktop-tauri/src-tauri && cargo test --features test-helpers --test vault_watcher_test +``` + +Expected: `4 passed`. If `debounces_rapid_writes_to_same_file` is flaky on macOS FSEvents (coalescing latency varies under load), bump the upper bound from 3 to 5 events. Document any change in a code comment. + +- [ ] **Step 10.6: Commit** + +```bash +git add apps/desktop-tauri/src-tauri/src/vault/watcher.rs \ + apps/desktop-tauri/src-tauri/tests/vault_watcher_test.rs \ + apps/desktop-tauri/src-tauri/Cargo.toml +git commit -m "m3(vault): watcher.rs notify+debounce emitting VaultEvent {path, kind}" +``` + +--- + +## Task 11: Vault Tauri commands (`commands/vault.rs`) + +**Files:** +- Create: `apps/desktop-tauri/src-tauri/src/commands/vault.rs` +- Modify: `apps/desktop-tauri/src-tauri/src/commands/mod.rs` +- Modify: `apps/desktop-tauri/src-tauri/src/lib.rs` (register handlers + start/stop watcher hooks) + +- [ ] **Step 11.1: Implement `commands/vault.rs`** + +Create `apps/desktop-tauri/src-tauri/src/commands/vault.rs`: + +```rust +//! Vault command surface. Thin async wrappers over `vault::*` modules. +//! +//! Every command takes a single named-input struct. Path-bearing +//! commands always go through `paths::resolve_*` before any FS call — +//! the renderer can never poke a path outside the open vault. +//! +//! The commands fall into three groups: +//! 1. lifecycle: open, close, get_status, get_current +//! 2. registry: get_all, switch, remove +//! 3. note IO: list_notes, read_note, write_note, delete_note, +//! get_config, update_config, reveal, reindex (no-op until M7) + +use crate::app_state::AppState; +use crate::error::{AppError, AppResult}; +use crate::vault::{ + fs as vfs, frontmatter::NoteFrontmatter, notes_io, paths, preferences, + registry::VaultInfo, state::VaultStatus, watcher, +}; +use std::path::PathBuf; +use tauri::{AppHandle, Emitter, State}; + +#[derive(serde::Deserialize, specta::Type)] +#[serde(rename_all = "camelCase")] +pub struct VaultOpenInput { + pub path: String, +} + +#[derive(serde::Serialize, specta::Type)] +#[serde(rename_all = "camelCase")] +pub struct VaultOpenOutput { + pub success: bool, + pub vault: Option, + pub error: Option, +} + +#[tauri::command] +#[specta::specta] +pub async fn vault_open( + state: State<'_, AppState>, + app: AppHandle, + input: VaultOpenInput, +) -> AppResult { + let target = PathBuf::from(&input.path); + if !target.is_dir() { + return Ok(VaultOpenOutput { + success: false, + vault: None, + error: Some(format!("not a directory: {}", input.path)), + }); + } + if let Err(e) = std::fs::metadata(&target).and_then(|m| { + if m.permissions().readonly() { + Err(std::io::Error::new( + std::io::ErrorKind::PermissionDenied, + "vault path is read-only", + )) + } else { + Ok(()) + } + }) { + return Ok(VaultOpenOutput { + success: false, + vault: None, + error: Some(e.to_string()), + }); + } + + preferences::init_vault(&target)?; + state.vault.set_indexing(true, 0); + + // Stop any prior watcher. + { + let mut slot = state + .vault + .watcher_slot + .lock() + .unwrap_or_else(|p| p.into_inner()); + slot.take(); + } + + state.vault.set_current(Some(target.clone()))?; + + // Compute counts cheaply for the registry blurb. + let cfg = preferences::read_config(&target)?; + let note_count = preferences::count_markdown_files(&target, &cfg.exclude_patterns); + + let info = VaultInfo { + path: target.to_string_lossy().into_owned(), + name: preferences::vault_name(&target), + note_count, + task_count: 0, + last_opened: now_iso(), + is_default: state + .vault + .registry_snapshot() + .vaults + .is_empty(), + }; + state.vault.upsert_registry(info.clone())?; + state.vault.touch_registry(&info.path)?; + + // Start watcher. + let app_handle = app.clone(); + let (tx, mut rx) = tokio::sync::mpsc::unbounded_channel(); + let handle = watcher::start(&target, tx)?; + { + let mut slot = state + .vault + .watcher_slot + .lock() + .unwrap_or_else(|p| p.into_inner()); + *slot = Some(handle); + } + tokio::spawn(async move { + while let Some(event) = rx.recv().await { + let _ = app_handle.emit("vault-changed", &event); + } + }); + + state.vault.set_indexing(false, 100); + + let _ = app.emit("vault-status-changed", &state.vault.status()); + + Ok(VaultOpenOutput { + success: true, + vault: Some(info), + error: None, + }) +} + +#[tauri::command] +#[specta::specta] +pub async fn vault_close(state: State<'_, AppState>, app: AppHandle) -> AppResult<()> { + { + let mut slot = state + .vault + .watcher_slot + .lock() + .unwrap_or_else(|p| p.into_inner()); + slot.take(); + } + state.vault.set_current(None)?; + state.vault.set_indexing(false, 0); + let _ = app.emit("vault-status-changed", &state.vault.status()); + Ok(()) +} + +#[tauri::command] +#[specta::specta] +pub async fn vault_get_status(state: State<'_, AppState>) -> AppResult { + Ok(state.vault.status()) +} + +#[derive(serde::Serialize, specta::Type)] +#[serde(rename_all = "camelCase")] +pub struct VaultCurrent { + pub path: Option, +} + +#[tauri::command] +#[specta::specta] +pub async fn vault_get_current(state: State<'_, AppState>) -> AppResult { + Ok(VaultCurrent { + path: state + .vault + .current_path() + .map(|p| p.to_string_lossy().into_owned()), + }) +} + +#[derive(serde::Serialize, specta::Type)] +#[serde(rename_all = "camelCase")] +pub struct VaultGetAllOutput { + pub vaults: Vec, + pub current_vault: Option, +} + +#[tauri::command] +#[specta::specta] +pub async fn vault_get_all(state: State<'_, AppState>) -> AppResult { + let snap = state.vault.registry_snapshot(); + Ok(VaultGetAllOutput { + vaults: snap.vaults, + current_vault: snap.current, + }) +} + +#[derive(serde::Deserialize, specta::Type)] +#[serde(rename_all = "camelCase")] +pub struct VaultPathInput { + pub path: String, +} + +#[tauri::command] +#[specta::specta] +pub async fn vault_switch( + state: State<'_, AppState>, + app: AppHandle, + input: VaultPathInput, +) -> AppResult { + vault_open(state, app, VaultOpenInput { path: input.path }).await +} + +#[tauri::command] +#[specta::specta] +pub async fn vault_remove( + state: State<'_, AppState>, + app: AppHandle, + input: VaultPathInput, +) -> AppResult<()> { + let current = state.vault.current_path(); + if current + .as_ref() + .map(|p| p.to_string_lossy().into_owned()) + == Some(input.path.clone()) + { + let _ = vault_close(state.clone(), app.clone()).await; + } + state.vault.remove_from_registry(&input.path)?; + Ok(()) +} + +#[tauri::command] +#[specta::specta] +pub async fn vault_get_config(state: State<'_, AppState>) -> AppResult { + let path = state.vault.require_current()?; + preferences::read_config(&path) +} + +#[derive(serde::Deserialize, specta::Type)] +#[serde(rename_all = "camelCase")] +pub struct VaultUpdateConfigInput { + pub exclude_patterns: Option>, + pub default_note_folder: Option, + pub journal_folder: Option, + pub attachments_folder: Option, +} + +#[tauri::command] +#[specta::specta] +pub async fn vault_update_config( + state: State<'_, AppState>, + input: VaultUpdateConfigInput, +) -> AppResult { + let path = state.vault.require_current()?; + let mut cfg = preferences::read_config(&path)?; + if let Some(p) = input.exclude_patterns { cfg.exclude_patterns = p; } + if let Some(s) = input.default_note_folder { cfg.default_note_folder = s; } + if let Some(s) = input.journal_folder { cfg.journal_folder = s; } + if let Some(s) = input.attachments_folder { cfg.attachments_folder = s; } + preferences::update_config(&path, &cfg) +} + +#[derive(serde::Serialize, specta::Type)] +#[serde(rename_all = "camelCase")] +pub struct VaultListNotesOutput { + pub paths: Vec, +} + +#[tauri::command] +#[specta::specta] +pub async fn vault_list_notes(state: State<'_, AppState>) -> AppResult { + let path = state.vault.require_current()?; + let entries = vfs::list_supported_files(&path).await?; + let only_md: Vec = entries + .into_iter() + .filter(|p| p.ends_with(".md") || p.ends_with(".markdown")) + .collect(); + Ok(VaultListNotesOutput { paths: only_md }) +} + +#[derive(serde::Deserialize, specta::Type)] +#[serde(rename_all = "camelCase")] +pub struct VaultReadNoteInput { + pub relative_path: String, +} + +#[tauri::command] +#[specta::specta] +pub async fn vault_read_note( + state: State<'_, AppState>, + input: VaultReadNoteInput, +) -> AppResult> { + let root = state.vault.require_current()?; + notes_io::read_note_from_disk(&root, &input.relative_path).await +} + +#[derive(serde::Deserialize, specta::Type)] +#[serde(rename_all = "camelCase")] +pub struct VaultWriteNoteInput { + pub relative_path: String, + pub frontmatter: NoteFrontmatter, + pub content: String, +} + +#[tauri::command] +#[specta::specta] +pub async fn vault_write_note( + state: State<'_, AppState>, + input: VaultWriteNoteInput, +) -> AppResult { + let root = state.vault.require_current()?; + notes_io::write_note_to_disk( + &root, + &input.relative_path, + &input.frontmatter, + &input.content, + ) + .await +} + +#[tauri::command] +#[specta::specta] +pub async fn vault_delete_note( + state: State<'_, AppState>, + input: VaultReadNoteInput, +) -> AppResult<()> { + let root = state.vault.require_current()?; + notes_io::delete_note_from_disk(&root, &input.relative_path).await +} + +#[tauri::command] +#[specta::specta] +pub async fn vault_reveal(state: State<'_, AppState>) -> AppResult<()> { + let path = state.vault.require_current()?; + crate::commands::shell::reveal_in_finder_inner(&path) +} + +/// Deferred to M7 (rebuildable index.db). Returns a fixed payload so +/// the renderer's settings UI can render its "reindex" button without +/// breaking in production. +#[derive(serde::Serialize, specta::Type)] +#[serde(rename_all = "camelCase")] +pub struct VaultReindexOutput { + pub success: bool, + pub files_indexed: i64, + pub duration: i64, + pub deferred_until: String, +} + +#[tauri::command] +#[specta::specta] +pub async fn vault_reindex(_state: State<'_, AppState>) -> AppResult { + Ok(VaultReindexOutput { + success: true, + files_indexed: 0, + duration: 0, + deferred_until: "M7".into(), + }) +} + +fn now_iso() -> String { + use std::time::{SystemTime, UNIX_EPOCH}; + let secs = SystemTime::now() + .duration_since(UNIX_EPOCH) + .map(|d| d.as_secs()) + .unwrap_or(0); + crate::vault::frontmatter_iso(secs) +} +``` + +- [ ] **Step 11.2: Update `commands/mod.rs`** + +Replace the current contents with: + +```rust +//! IPC command surface exposed to the renderer. + +pub mod settings; +pub mod vault; +pub mod shell; +pub mod dialog; +``` + +- [ ] **Step 11.3: Register every vault command in `lib.rs::run`** + +Open `apps/desktop-tauri/src-tauri/src/lib.rs`. Replace the `.invoke_handler(tauri::generate_handler![...])` block with: + +```rust +.invoke_handler(tauri::generate_handler![ + commands::settings::settings_get, + commands::settings::settings_set, + commands::settings::settings_list, + commands::vault::vault_open, + commands::vault::vault_close, + commands::vault::vault_get_status, + commands::vault::vault_get_current, + commands::vault::vault_get_all, + commands::vault::vault_switch, + commands::vault::vault_remove, + commands::vault::vault_get_config, + commands::vault::vault_update_config, + commands::vault::vault_list_notes, + commands::vault::vault_read_note, + commands::vault::vault_write_note, + commands::vault::vault_delete_note, + commands::vault::vault_reveal, + commands::vault::vault_reindex, + commands::shell::shell_open_url, + commands::shell::shell_open_path, + commands::shell::shell_reveal_in_finder, + commands::dialog::dialog_choose_folder, + commands::dialog::dialog_choose_files, +]) +``` + +- [ ] **Step 11.4: Verify cargo check (commands not implemented yet — Step 11.5 ports those over)** + +The shell/dialog modules are stubbed in Task 12; for now expose empty modules so this compiles. Touch them as empty: + +```bash +touch apps/desktop-tauri/src-tauri/src/commands/shell.rs apps/desktop-tauri/src-tauri/src/commands/dialog.rs +``` + +Add minimal stubs in each so the macros find symbols. Open `commands/shell.rs`: + +```rust +//! Stubbed in Task 11; populated in Task 12. + +use crate::error::AppResult; + +#[tauri::command] +#[specta::specta] +pub async fn shell_open_url(_url: String) -> AppResult<()> { Ok(()) } + +#[tauri::command] +#[specta::specta] +pub async fn shell_open_path(_path: String) -> AppResult<()> { Ok(()) } + +#[tauri::command] +#[specta::specta] +pub async fn shell_reveal_in_finder(_path: String) -> AppResult<()> { Ok(()) } + +pub(crate) fn reveal_in_finder_inner(_path: &std::path::Path) -> AppResult<()> { Ok(()) } +``` + +Open `commands/dialog.rs`: + +```rust +//! Stubbed in Task 11; populated in Task 12. + +use crate::error::AppResult; + +#[tauri::command] +#[specta::specta] +pub async fn dialog_choose_folder(_title: Option) -> AppResult> { + Ok(None) +} + +#[tauri::command] +#[specta::specta] +pub async fn dialog_choose_files( + _title: Option, + _filters: Option>, +) -> AppResult> { + Ok(Vec::new()) +} +``` + +- [ ] **Step 11.5: Confirm cargo check + clippy pass** + +```bash +cd apps/desktop-tauri/src-tauri && cargo check && cargo clippy -- -D warnings +``` + +Expected: pass. + +- [ ] **Step 11.6: Commit** + +```bash +git add apps/desktop-tauri/src-tauri/src/commands \ + apps/desktop-tauri/src-tauri/src/lib.rs +git commit -m "m3(commands): vault_* command surface (open/close/list/read/write/...) + shell/dialog stubs" +``` + +--- + +## Task 12: Native shell + dialog commands (`commands/shell.rs`, `commands/dialog.rs`) + +**Files:** +- Modify: `apps/desktop-tauri/src-tauri/src/commands/shell.rs` +- Modify: `apps/desktop-tauri/src-tauri/src/commands/dialog.rs` +- Modify: `apps/desktop-tauri/src-tauri/src/lib.rs` (register dialog plugin) +- Modify: `apps/desktop-tauri/src-tauri/capabilities/default.json` + +- [ ] **Step 12.1: Replace `commands/shell.rs` with the real impl** + +```rust +//! `shell.*` parity commands. +//! +//! - `shell_open_url(url)` opens an http(s) URL in the user's default +//! browser via `tauri-plugin-shell`. Rejects non-http schemes. +//! - `shell_open_path(path)` opens a local file/folder with the OS +//! default handler. The path must be absolute. +//! - `shell_reveal_in_finder(path)` selects the path in Finder +//! (`open -R` on macOS). + +use crate::error::{AppError, AppResult}; +use std::path::Path; +use tauri::AppHandle; +use tauri_plugin_shell::ShellExt; + +#[tauri::command] +#[specta::specta] +pub async fn shell_open_url(app: AppHandle, url: String) -> AppResult<()> { + if !(url.starts_with("https://") || url.starts_with("http://")) { + return Err(AppError::Validation(format!("non-http url: {url}"))); + } + app.shell() + .open(url, None) + .map_err(|e| AppError::Vault(format!("shell open failed: {e}"))) +} + +#[tauri::command] +#[specta::specta] +pub async fn shell_open_path(app: AppHandle, path: String) -> AppResult<()> { + let p = Path::new(&path); + if !p.is_absolute() { + return Err(AppError::Validation(format!("path must be absolute: {path}"))); + } + if !p.exists() { + return Err(AppError::NotFound(path.clone())); + } + app.shell() + .open(path, None) + .map_err(|e| AppError::Vault(format!("shell open failed: {e}"))) +} + +#[tauri::command] +#[specta::specta] +pub async fn shell_reveal_in_finder(path: String) -> AppResult<()> { + let p = Path::new(&path); + if !p.is_absolute() { + return Err(AppError::Validation(format!("path must be absolute: {path}"))); + } + reveal_in_finder_inner(p) +} + +pub(crate) fn reveal_in_finder_inner(path: &Path) -> AppResult<()> { + #[cfg(target_os = "macos")] + { + std::process::Command::new("open") + .arg("-R") + .arg(path) + .spawn() + .map(|_| ()) + .map_err(|e| AppError::Vault(format!("open -R failed: {e}"))) + } + #[cfg(not(target_os = "macos"))] + { + Err(AppError::Validation( + "reveal in finder is macOS-only in v1".into(), + )) + } +} +``` + +- [ ] **Step 12.2: Replace `commands/dialog.rs` with the real impl** + +```rust +//! Native folder + file picker commands using +//! `tauri-plugin-dialog`. Returns POSIX path strings (forward slashes +//! on macOS). + +use crate::error::{AppError, AppResult}; +use tauri::AppHandle; +use tauri_plugin_dialog::DialogExt; + +#[tauri::command] +#[specta::specta] +pub async fn dialog_choose_folder( + app: AppHandle, + title: Option, +) -> AppResult> { + let mut builder = app.dialog().file(); + if let Some(t) = &title { + builder = builder.set_title(t); + } + let (tx, rx) = std::sync::mpsc::channel(); + builder.pick_folder(move |result| { + let _ = tx.send(result); + }); + let result = rx.recv().map_err(|e| AppError::Internal(e.to_string()))?; + Ok(result.map(|p| p.to_string())) +} + +#[tauri::command] +#[specta::specta] +pub async fn dialog_choose_files( + app: AppHandle, + title: Option, + filters: Option>, +) -> AppResult> { + let mut builder = app.dialog().file(); + if let Some(t) = &title { + builder = builder.set_title(t); + } + if let Some(exts) = filters.as_ref() { + if !exts.is_empty() { + let mut owned: Vec<&str> = exts.iter().map(String::as_str).collect(); + // Tauri's filter API expects (name, &[ext]). + let _name = "Allowed"; + builder = builder.add_filter("Allowed", &owned); + owned.clear(); + } + } + let (tx, rx) = std::sync::mpsc::channel(); + builder.pick_files(move |paths| { + let _ = tx.send(paths); + }); + let result = rx.recv().map_err(|e| AppError::Internal(e.to_string()))?; + Ok(result + .map(|paths| paths.into_iter().map(|p| p.to_string()).collect()) + .unwrap_or_default()) +} +``` + +- [ ] **Step 12.3: Register the dialog plugin in `lib.rs::run`** + +Find the existing `.plugin(tauri_plugin_shell::init())` line and add directly after it: + +```rust +.plugin(tauri_plugin_dialog::init()) +``` + +- [ ] **Step 12.4: Extend `capabilities/default.json`** + +Replace the file with: + +```json +{ + "$schema": "../gen/schemas/desktop-schema.json", + "identifier": "default", + "description": "Default capability grants for Memry desktop app", + "windows": ["main"], + "permissions": [ + "core:default", + "core:window:allow-close", + "core:window:allow-minimize", + "core:window:allow-maximize", + "core:window:allow-unmaximize", + "core:window:allow-start-dragging", + "core:event:allow-listen", + "core:event:allow-unlisten", + "core:webview:allow-print", + "dialog:default", + "dialog:allow-open", + "shell:default", + "shell:allow-open" + ] +} +``` + +`shell:allow-open` is the permission needed for `shell.open`. `dialog:allow-open` covers `pick_folder`/`pick_files`. The `core:event:*` grants are needed by the renderer to subscribe to `vault-changed` and `vault-status-changed` from background threads. + +- [ ] **Step 12.5: Verify capability:check passes** + +```bash +cd /Users/h4yfans/sideproject/memry-worktrees/spike-tauri-m3 && \ + pnpm --filter @memry/desktop-tauri capability:check +``` + +Expected: exits 0. The script cross-references `Cargo.toml` plugins against `capabilities/default.json` permissions; missing grants fail with a useful error. + +- [ ] **Step 12.6: Verify cargo + clippy clean** + +```bash +cd apps/desktop-tauri/src-tauri && cargo check && cargo clippy -- -D warnings +``` + +- [ ] **Step 12.7: Manual smoke (real Tauri window required)** + +```bash +pnpm --filter @memry/desktop-tauri dev +``` + +Open the dev console and run: + +```js +await window.__TAURI__.core.invoke('shell_open_url', { url: 'https://example.com' }) +await window.__TAURI__.core.invoke('shell_reveal_in_finder', { path: '/tmp' }) +const folder = await window.__TAURI__.core.invoke('dialog_choose_folder', {}) +console.log('chose', folder) +``` + +Expected: browser opens, Finder reveals `/tmp`, folder picker appears. Cancel returns `null`. Document the smoke completion in the PR body. + +- [ ] **Step 12.8: Commit** + +```bash +git add apps/desktop-tauri/src-tauri/src/commands/shell.rs \ + apps/desktop-tauri/src-tauri/src/commands/dialog.rs \ + apps/desktop-tauri/src-tauri/src/lib.rs \ + apps/desktop-tauri/src-tauri/capabilities/default.json +git commit -m "m3(commands): native shell.open / dialog.pick + capability grants" +``` + +--- + +## Task 13: `memry-file://` custom URI scheme protocol handler + +**Files:** +- Modify: `apps/desktop-tauri/src-tauri/src/lib.rs` +- Modify: `apps/desktop-tauri/src-tauri/tauri.conf.json` +- Create: `apps/desktop-tauri/src/lib/memry-file.ts` + +- [ ] **Step 13.1: Register the URI scheme in `tauri.conf.json`** + +Open `apps/desktop-tauri/src-tauri/tauri.conf.json`. Inside the `app` object, after `windows`, add: + +```json + "withGlobalTauri": false, +``` + +Then add a top-level `app.security` `assetProtocol` entry — wait, in Tauri 2 custom URI scheme protocols are registered via `tauri::Builder::register_uri_scheme_protocol`. The conf only needs the CSP entry. Update `app.security.csp` to: + +```json +"csp": "default-src 'self' memry-file:; script-src 'self'; style-src 'self' 'unsafe-inline'; img-src 'self' data: blob: memry-file: https:; media-src 'self' blob: data: memry-file:; frame-src https://www.youtube.com https://www.youtube-nocookie.com https://player.vimeo.com https://player.twitch.tv; font-src 'self' data:; worker-src 'self' blob:; connect-src 'self' ipc: https://ipc.localhost http://localhost:1420 https://*.youtube.com" +``` + +Compared to M2 baseline this only adds `memry-file:` to `default-src`, `img-src`, and `media-src`. No third-party host opens up. + +- [ ] **Step 13.2: Implement the protocol handler in `lib.rs::run`** + +Open `apps/desktop-tauri/src-tauri/src/lib.rs`. Locate the `tauri::Builder::default()` chain. After the `.plugin(tauri_plugin_dialog::init())` line, insert: + +```rust + .register_uri_scheme_protocol("memry-file", |ctx, request| { + let app = ctx.app_handle().clone(); + let response = handle_memry_file(&app, &request); + response + }) +``` + +Then add the handler at the bottom of the file: + +```rust +fn handle_memry_file( + app: &tauri::AppHandle, + request: &tauri::http::Request>, +) -> tauri::http::Response> { + use std::fs; + use std::io::Read; + use tauri::http::{header, Response, StatusCode}; + + let url = request.uri().to_string(); + // Format: memry-file://local/ + let path = match url.strip_prefix("memry-file://local/") { + Some(p) => format!("/{}", urlencoding::decode(p).unwrap_or_default()), + None => { + return Response::builder() + .status(StatusCode::BAD_REQUEST) + .body(b"invalid memry-file url".to_vec()) + .unwrap(); + } + }; + let abs = match dunce::canonicalize(&path) { + Ok(a) => a, + Err(_) => return missing(&path), + }; + + // Allowlist: app data dir + current vault root. + let mut allowed: Vec = Vec::new(); + if let Some(state) = app.try_state::() { + if let Some(vault) = state.vault.current_path() { + if let Ok(c) = dunce::canonicalize(&vault) { + allowed.push(c); + } + } + } + if let Ok(dirs) = directories::ProjectDirs::from("com", "memry", "memry") + .ok_or(()) + .and_then(|d| Ok(d.data_dir().to_path_buf())) + { + if let Ok(c) = dunce::canonicalize(&dirs) { + allowed.push(c); + } + } + if !allowed.iter().any(|root| abs.starts_with(root)) { + return Response::builder() + .status(StatusCode::FORBIDDEN) + .body(b"path not in allowed roots".to_vec()) + .unwrap(); + } + + let bytes = match fs::read(&abs) { + Ok(b) => b, + Err(_) => return missing(&path), + }; + + let mime = mime_guess::from_path(&abs) + .first_or_octet_stream() + .essence_str() + .to_string(); + + if let Some(range) = request.headers().get(header::RANGE) { + if let Ok(range_str) = range.to_str() { + if let Some(captures) = parse_range(range_str, bytes.len() as u64) { + let (start, end) = captures; + let slice = &bytes[start as usize..=end as usize]; + let len = slice.len(); + return Response::builder() + .status(StatusCode::PARTIAL_CONTENT) + .header(header::CONTENT_TYPE, mime) + .header( + header::CONTENT_RANGE, + format!("bytes {start}-{end}/{}", bytes.len()), + ) + .header(header::CONTENT_LENGTH, len.to_string()) + .header(header::ACCEPT_RANGES, "bytes") + .body(slice.to_vec()) + .unwrap(); + } + } + } + + Response::builder() + .status(StatusCode::OK) + .header(header::CONTENT_TYPE, mime) + .header(header::CONTENT_LENGTH, bytes.len().to_string()) + .header(header::ACCEPT_RANGES, "bytes") + .body(bytes) + .unwrap() +} + +fn missing(path: &str) -> tauri::http::Response> { + use tauri::http::{header, Response, StatusCode}; + let lower = path.to_lowercase(); + let is_image = lower.ends_with(".png") + || lower.ends_with(".jpg") + || lower.ends_with(".jpeg") + || lower.ends_with(".gif") + || lower.ends_with(".webp"); + if is_image { + // 1x1 transparent PNG + let bytes = base64_decode_static( + "iVBORw0KGgoAAAANSUhEUgAAAAEAAAABCAQAAAC1HAwCAAAAC0lEQVR42mNkYAAAAAYAAjCB0C8AAAAASUVORK5CYII=", + ); + return Response::builder() + .status(StatusCode::OK) + .header(header::CONTENT_TYPE, "image/png") + .body(bytes) + .unwrap(); + } + Response::builder() + .status(StatusCode::NOT_FOUND) + .body(b"not found".to_vec()) + .unwrap() +} + +fn parse_range(header_value: &str, total: u64) -> Option<(u64, u64)> { + let v = header_value.strip_prefix("bytes=")?; + let (start_str, end_str) = v.split_once('-')?; + let start: u64 = start_str.parse().ok().unwrap_or(0); + let end: u64 = if end_str.is_empty() { + total.saturating_sub(1) + } else { + end_str.parse().ok().unwrap_or(total.saturating_sub(1)) + }; + if start > end || end >= total { + return None; + } + Some((start, end)) +} + +fn base64_decode_static(input: &str) -> Vec { + use std::collections::HashMap; + let alphabet = + b"ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/"; + let mut lookup = HashMap::new(); + for (i, c) in alphabet.iter().enumerate() { + lookup.insert(*c as char, i as u8); + } + let mut buf = 0u32; + let mut bits = 0u32; + let mut out = Vec::with_capacity(input.len() * 3 / 4); + for c in input.chars() { + if c == '=' { + break; + } + if let Some(v) = lookup.get(&c) { + buf = (buf << 6) | *v as u32; + bits += 6; + if bits >= 8 { + bits -= 8; + out.push((buf >> bits) as u8); + buf &= (1u32 << bits) - 1; + } + } + } + out +} +``` + +- [ ] **Step 13.3: Add `urlencoding` to `Cargo.toml`** + +```toml +urlencoding = "2.1" +``` + +- [ ] **Step 13.4: Add the renderer-side `toMemryFileUrl` helper** + +Create `apps/desktop-tauri/src/lib/memry-file.ts`: + +```ts +/** + * Build a memry-file:// URL from an absolute local path. + * + * Mirrors the Electron helper of the same name. The Tauri custom URI + * scheme handler in src-tauri/src/lib.rs decodes percent-encoded + * paths, so encodeURI is correct here. + */ +export function toMemryFileUrl(absolutePath: string): string { + const normalized = absolutePath.replace(/^\/+/, '') + return `memry-file://local/${encodeURI(normalized)}` +} + +export function fromMemryFileUrl(url: string): string { + const prefix = 'memry-file://local/' + if (!url.startsWith(prefix)) { + throw new Error(`Invalid memry-file URL: ${url}`) + } + const rest = decodeURIComponent(url.slice(prefix.length)) + return '/' + rest +} +``` + +- [ ] **Step 13.5: Manual smoke** + +Drop a small test image into your scratch vault: + +```bash +cp ~/Pictures/any.png ~/memry-test-vault-m3/attachments/images/test.png +``` + +Rebuild and open dev: + +```bash +pnpm --filter @memry/desktop-tauri dev +``` + +In dev console: + +```js +const url = `memry-file://local/${encodeURI(`${Object.values(window).find(v => v && v.__TAURI__)?.__TAURI__?.path?.appDataDir?.() || ''}`).replace(/^\/+/,'')}` +const test = 'memry-file://local/' + encodeURI(`${'/Users/' + 'YOU' + '/memry-test-vault-m3/attachments/images/test.png'}`.replace(/^\/+/,'')) +const img = new Image() +img.onload = () => console.log('image loaded', img.width, img.height) +img.onerror = (e) => console.error('image failed', e) +img.src = test +``` + +Expected: image renders. Repeat for a missing image — expect a 1×1 transparent PNG response (no console error, broken-image icon does not appear). Repeat for an outside-vault path (e.g. `/etc/hosts`) — expect a 403 response. + +- [ ] **Step 13.6: Document the smoke result in the PR body** (Task 16) + +- [ ] **Step 13.7: Commit** + +```bash +git add apps/desktop-tauri/src-tauri/src/lib.rs \ + apps/desktop-tauri/src-tauri/Cargo.toml \ + apps/desktop-tauri/src-tauri/Cargo.lock \ + apps/desktop-tauri/src-tauri/tauri.conf.json \ + apps/desktop-tauri/src/lib/memry-file.ts +git commit -m "m3(protocol): memry-file:// URI scheme with byte-range + missing-image fallback" +``` + +--- + +## Task 14: Drag-drop path-resolution spike + +**Files:** +- Modify: `apps/desktop-tauri/src-tauri/src/lib.rs` (subscribe to drag-drop events) +- Modify: `apps/desktop-tauri/src-tauri/capabilities/default.json` (drop event grants) +- Create: `apps/desktop-tauri/scripts/drag-drop-smoke.md` (documented manual smoke) + +- [ ] **Step 14.1: Capability — already covered** + +`core:default` includes the file-drop event grants in Tauri 2.x. Confirm by inspecting the schema: + +```bash +grep -n 'drag-drop\|dragDropEvent\|drop' apps/desktop-tauri/src-tauri/gen/schemas/desktop-schema.json | head -5 +``` + +Expected: at least one `drop` reference in `core:default`. If absent, add `core:webview:allow-on-drag-drop-event` to `permissions`. + +- [ ] **Step 14.2: Subscribe to drag-drop events from the main window** + +Open `apps/desktop-tauri/src-tauri/src/lib.rs`. Inside the `.setup(|app| { ... })` closure, AFTER the `tracing_subscriber::fmt()...` block, add: + +```rust + let main_window = app + .get_webview_window("main") + .ok_or_else(|| anyhow::anyhow!("main window missing")) + .map_err(|e| Box::new(std::io::Error::new(std::io::ErrorKind::Other, e.to_string())) as Box)?; + let main_clone = main_window.clone(); + main_window.on_window_event(move |event| { + if let tauri::WindowEvent::DragDrop(drag) = event { + if let tauri::DragDropEvent::Drop { paths, .. } = drag { + let path_strs: Vec = + paths.iter().map(|p| p.to_string_lossy().into_owned()).collect(); + let _ = main_clone.app_handle().emit("vault-drag-drop", &path_strs); + } + } + }); +``` + +Tauri 2 emits absolute paths with the drop event — drop events on macOS WebKit work natively in M3, so the renderer never has to rely on the Electron-only `webUtils.getPathForFile`. + +> The `anyhow` import is just to keep the closure error-cast simple. +> Add `anyhow = "1"` to `[dependencies]` if not already present. + +- [ ] **Step 14.3: Renderer subscribes to `vault-drag-drop`** + +This task delivers the spike, not the import feature itself (file import lands in M8). Still, prove the wiring works end-to-end. Add a tiny logger in `apps/desktop-tauri/src/main.tsx`: + +Find the `createRoot` block. Right after `await ensureLibsodium()` (or the earliest top-level await), add: + +```ts +import { listen } from '@tauri-apps/api/event' + +void listen('vault-drag-drop', (event) => { + // Spike telemetry only. Replaced by real import handler in M8. + console.info('[drag-drop spike] paths:', event.payload) +}) +``` + +This is a temporary spike marker — Task 16's verification step deletes the import once the smoke is documented. + +- [ ] **Step 14.4: Run the manual smoke** + +```bash +pnpm --filter @memry/desktop-tauri dev +``` + +In a Finder window, select an image, a PDF, and a video. Drag them into the running Tauri window. In the dev console you should see: + +```text +[drag-drop spike] paths: ["/Users/.../foo.png", "/Users/.../doc.pdf", "/Users/.../clip.mp4"] +``` + +If paths are received, the spike is 🟢. If you see `webkit-fake-url://` strings (old WebKit fallback), the spike is 🔴 — fall back to a `dialog_choose_files` import flow (already implemented in Task 12) and document this in `scripts/drag-drop-smoke.md` as the canonical fallback. + +- [ ] **Step 14.5: Document the smoke** + +Create `apps/desktop-tauri/scripts/drag-drop-smoke.md`: + +```markdown +# M3 drag-drop path-resolution spike + +Run `pnpm --filter @memry/desktop-tauri dev`, drag files into the +window, watch dev console for `[drag-drop spike] paths:` log line. + +| Outcome | What it means | Action | +|---|---|---| +| Real `/Users/...` paths | macOS WebKit + Tauri 2 deliver real paths. | M8 file import can rely on drop events. | +| `webkit-fake-url://` | Native drop didn't work. | Fall back to `dialog_choose_files` for file imports. | + +Last verified: , macOS , Tauri 2.10, Memry desktop-tauri. +``` + +Fill in the date/version after the smoke. + +- [ ] **Step 14.6: Commit** + +```bash +git add apps/desktop-tauri/src-tauri/src/lib.rs \ + apps/desktop-tauri/src-tauri/Cargo.toml \ + apps/desktop-tauri/src-tauri/capabilities/default.json \ + apps/desktop-tauri/src/main.tsx \ + apps/desktop-tauri/scripts/drag-drop-smoke.md +git commit -m "m3(spike): drag-drop path resolution + documented fallback to dialog picker" +``` + +--- + +## Task 15: Bindings regen + mock-swap + renderer integration + +**Files:** +- Modify: `apps/desktop-tauri/src-tauri/src/bin/generate_bindings.rs` +- Modify: `apps/desktop-tauri/src/lib/ipc/invoke.ts` +- Modify: `apps/desktop-tauri/src/lib/ipc/mocks/vault.ts` +- Create: `apps/desktop-tauri/e2e/specs/m3-vault-smoke.spec.ts` +- Modify: `apps/desktop-tauri/src/services/vault-service.ts` (small adapter shape changes) + +- [ ] **Step 15.1: Extend `generate_bindings.rs`** + +Open `apps/desktop-tauri/src-tauri/src/bin/generate_bindings.rs`. Replace the `collect_commands![...]` macro and `.typ::<...>()` chain with: + +```rust +.commands(collect_commands![ + commands::settings::settings_get, + commands::settings::settings_set, + commands::settings::settings_list, + commands::vault::vault_open, + commands::vault::vault_close, + commands::vault::vault_get_status, + commands::vault::vault_get_current, + commands::vault::vault_get_all, + commands::vault::vault_switch, + commands::vault::vault_remove, + commands::vault::vault_get_config, + commands::vault::vault_update_config, + commands::vault::vault_list_notes, + commands::vault::vault_read_note, + commands::vault::vault_write_note, + commands::vault::vault_delete_note, + commands::vault::vault_reveal, + commands::vault::vault_reindex, + commands::shell::shell_open_url, + commands::shell::shell_open_path, + commands::shell::shell_reveal_in_finder, + commands::dialog::dialog_choose_folder, + commands::dialog::dialog_choose_files, +]) +.typ::() +.typ::() +.typ::() +.typ::() +.typ::() +.typ::() +.typ::() +.typ::() +.typ::() +.typ::() +.typ::() +.typ::() +.typ::() +.typ::() +.typ::() +.typ::() +.typ::() +.typ::() +.typ::() +.typ::() +.typ::() +.typ::() +.typ::() +.typ::() +.typ::() +.typ::() +.typ::() +.typ::() +.typ::() +.typ::() +.typ::() +.typ::() +.typ::() +.typ::() +.typ::(); +``` + +Add `use memry_desktop_tauri_lib::vault;` at the top alongside the existing `commands` / `db` / `error` imports. + +- [ ] **Step 15.2: Regenerate bindings + verify** + +```bash +pnpm --filter @memry/desktop-tauri bindings:generate +pnpm --filter @memry/desktop-tauri bindings:check +``` + +Expected: clean. The generated `src/generated/bindings.ts` now contains every M3 type and command signature. + +- [ ] **Step 15.3: Add the swapped commands to `realCommands` in `invoke.ts`** + +Open `apps/desktop-tauri/src/lib/ipc/invoke.ts`. Replace the `realCommands` Set with: + +```ts +const realCommands = new Set([ + 'settings_get', + 'settings_set', + 'settings_list', + 'vault_open', + 'vault_close', + 'vault_get_status', + 'vault_get_current', + 'vault_get_all', + 'vault_switch', + 'vault_remove', + 'vault_get_config', + 'vault_update_config', + 'vault_list_notes', + 'vault_read_note', + 'vault_write_note', + 'vault_delete_note', + 'vault_reveal', + 'shell_open_url', + 'shell_open_path', + 'shell_reveal_in_finder', + 'dialog_choose_folder', + 'dialog_choose_files' +]) +``` + +Note `vault_reindex` stays on the mock path until M7 — the Rust stub returns `{ deferredUntil: 'M7' }` and the renderer does not need to know. + +- [ ] **Step 15.4: Trim the mock vault routes that are now real** + +Open `apps/desktop-tauri/src/lib/ipc/mocks/vault.ts`. Delete every route except `vault_reindex` and `vault_create` (the latter still has no Rust counterpart — the renderer's "create vault" flow uses `dialog_choose_folder` then `vault_open`, but the legacy `vault_create` mock stays for the existing onboarding component until M5 refactors it). + +The trimmed file: + +```ts +import type { MockRouteMap } from './types' + +const config = { + excludePatterns: ['.git', 'node_modules', '.DS_Store'], + defaultNoteFolder: 'notes', + journalFolder: 'journal', + attachmentsFolder: 'attachments' +} + +export const vaultRoutes: MockRouteMap = { + // M7 will replace this stub with a real index.db rebuild. + vault_reindex: async () => ({ success: true, filesIndexed: 0, duration: 0, deferredUntil: 'M7' }), + + // Legacy onboarding helper — replaced by dialog_choose_folder + vault_open in M5. + vault_create: async (args) => { + const { path, name } = args as { path: string; name: string } + return { + success: true, + vault: { + path, + name, + noteCount: 0, + taskCount: 0, + lastOpened: new Date().toISOString(), + isDefault: false + } + } + } +} +``` + +Update `mocks/index.ts` if it still imports the deleted route names — TypeScript will tell you on the next typecheck. + +- [ ] **Step 15.5: Adjust the vault service shape if needed** + +Open `apps/desktop-tauri/src/services/vault-service.ts`. The `createInvokeForwarder('vault')` call maps method names like `getStatus` to `vault_get_status`. Before M3 the renderer expected: + +- `vault_get_all` → `{ vaults, currentVault }` +- `vault_get_status` → `{ isOpen, path, isIndexing, indexProgress, error }` + +The Rust implementations match this shape. No service-layer change is required — but verify by running `pnpm --filter @memry/desktop-tauri test` and reading the failure output. Adjust the forwarder camelCase → snake_case mapping only if a test fails. + +- [ ] **Step 15.6: Add e2e smoke against the runtime lane** + +Create `apps/desktop-tauri/e2e/specs/m3-vault-smoke.spec.ts`: + +```ts +import { test, expect } from '@playwright/test' + +const TEST_VAULT = process.env.M3_TEST_VAULT_PATH ?? `${process.env.HOME}/memry-test-vault-m3` + +test.describe('M3 vault smoke', () => { + test('open vault, list notes, read+write a note', async ({ page }) => { + await page.goto('/') + + const result = await page.evaluate(async (path) => { + const { invoke } = (window as unknown as { + __TAURI__: { core: { invoke: (cmd: string, args?: Record) => Promise } } + }).__TAURI__.core + const open = await invoke('vault_open', { input: { path } }) + const status = await invoke('vault_get_status') + const list = await invoke('vault_list_notes') + return { open, status, list } + }, TEST_VAULT) + + expect(result.open).toMatchObject({ success: true }) + expect(result.status).toMatchObject({ isOpen: true }) + expect(Array.isArray((result.list as { paths: string[] }).paths)).toBe(true) + }) + + test('write then read roundtrip preserves Turkish chars', async ({ page }) => { + await page.goto('/') + + const out = await page.evaluate(async (path) => { + const { invoke } = (window as unknown as { + __TAURI__: { core: { invoke: (cmd: string, args?: Record) => Promise } } + }).__TAURI__.core + await invoke('vault_open', { input: { path } }) + const fm = { + id: 'm3-smoke-id', + title: 'Çalışma günü', + created: '2026-04-26T00:00:00Z', + modified: '2026-04-26T00:00:00Z', + tags: ['work'], + aliases: [], + emoji: null, + localOnly: null, + properties: null, + extra: {} + } + await invoke('vault_write_note', { + input: { + relativePath: 'notes/m3-smoke.md', + frontmatter: fm, + content: 'İçerik düzenlendi.' + } + }) + return await invoke('vault_read_note', { + input: { relativePath: 'notes/m3-smoke.md' } + }) + }, TEST_VAULT) + + expect(out).toBeTruthy() + expect((out as { parsed: { content: string } }).parsed.content).toBe( + 'İçerik düzenlendi.' + ) + }) +}) +``` + +This is a runtime-lane test — it requires the Tauri dev runtime, not the M1 mock-lane Vite WebKit. The mock-lane existing tests still cover visual parity. Adding a runtime lane is one of the spec's M5-prerequisite items; M3 starts the lane modestly with two smoke tests. + +If `playwright.config.ts` does not yet have a runtime-lane target, follow the comment in `e2e/playwright.config.ts` that documents the harness — for M3 it is acceptable to gate the suite behind `M3_TEST_VAULT_PATH` so CI does not run it without a vault checkout. + +- [ ] **Step 15.7: Verify all checks** + +```bash +pnpm --filter @memry/desktop-tauri lint +pnpm --filter @memry/desktop-tauri typecheck +pnpm --filter @memry/desktop-tauri test +pnpm --filter @memry/desktop-tauri bindings:check +pnpm --filter @memry/desktop-tauri capability:check +pnpm --filter @memry/desktop-tauri port:audit +pnpm --filter @memry/desktop-tauri command:parity +pnpm --filter @memry/desktop-tauri cargo:check +pnpm --filter @memry/desktop-tauri cargo:clippy +pnpm --filter @memry/desktop-tauri cargo:test +``` + +Expected: every command exits 0. The `command:parity` audit may flag `vault_reindex` and `vault_create` as still-mocked — both are documented deferrals and the audit needs an update in this commit. + +- [ ] **Step 15.8: Update `command:parity` ledger** + +Open `apps/desktop-tauri/scripts/command-parity-audit.ts`. Locate the deferral-classification list and add (or extend) the entries: + +```ts +{ command: 'vault_reindex', status: 'deferred', milestone: 'M7' }, +{ command: 'vault_create', status: 'mocked', milestone: 'M5' } +``` + +Re-run `pnpm --filter @memry/desktop-tauri command:parity` and confirm exit 0. + +- [ ] **Step 15.9: Commit** + +```bash +git add apps/desktop-tauri/src-tauri/src/bin/generate_bindings.rs \ + apps/desktop-tauri/src/generated/bindings.ts \ + apps/desktop-tauri/src/lib/ipc/invoke.ts \ + apps/desktop-tauri/src/lib/ipc/mocks/vault.ts \ + apps/desktop-tauri/src/lib/ipc/mocks/index.ts \ + apps/desktop-tauri/src/services/vault-service.ts \ + apps/desktop-tauri/scripts/command-parity-audit.ts \ + apps/desktop-tauri/e2e/specs/m3-vault-smoke.spec.ts +git commit -m "m3(renderer): swap vault_*/shell_*/dialog_* to real Rust + runtime e2e smoke" +``` + +--- + +## Task 16: Bench, acceptance gate, PR + +**Files:** +- Create: `apps/desktop-tauri/src-tauri/tests/vault_bench.rs` +- Modify: `apps/desktop-tauri/src-tauri/Cargo.toml` (add `[[test]]` entry) +- Read-only verification pass +- Modify: commit history / `git push` + +- [ ] **Step 16.1: Write the 100-note bench** + +Create `apps/desktop-tauri/src-tauri/tests/vault_bench.rs`: + +```rust +use memry_desktop_tauri_lib::vault::{fs as vfs, frontmatter, notes_io, preferences}; +use std::time::Instant; + +#[tokio::test(flavor = "multi_thread")] +async fn open_vault_with_100_notes_under_500ms() { + let vault = tempfile::tempdir().unwrap(); + preferences::init_vault(vault.path()).unwrap(); + for i in 0..100 { + let mut fm = frontmatter::create_frontmatter(&format!("Note {i}"), &["work".into()]); + fm.id = format!("seed-id-{i:03}"); + notes_io::write_note_to_disk( + vault.path(), + &format!("notes/note-{i:03}.md"), + &fm, + "body content goes here for the bench seed.", + ) + .await + .unwrap(); + } + + let start = Instant::now(); + let entries = vfs::list_supported_files(vault.path()).await.unwrap(); + let elapsed = start.elapsed(); + assert!(entries.len() >= 100); + assert!( + elapsed.as_millis() < 500, + "100-note vault scan took {:?}, exceeds 500ms acceptance gate", + elapsed + ); +} +``` + +Register the test in `Cargo.toml`: + +```toml +[[test]] +name = "vault_bench" +required-features = ["test-helpers"] +``` + +- [ ] **Step 16.2: Run the bench** + +```bash +cd apps/desktop-tauri/src-tauri && cargo test --release --features test-helpers --test vault_bench -- --nocapture +``` + +Expected: `100-note bench` passes well under 500ms. Local target on Apple silicon: <80ms. If it fails: +- Run release build (`--release` is critical — debug build is 5–10× slower). +- Check that `list_supported_files` is using `tokio::fs::read_dir` and not blocking IO on the executor thread. + +- [ ] **Step 16.3: Final acceptance gate verification** + +```bash +# Rust +pnpm --filter @memry/desktop-tauri cargo:check +pnpm --filter @memry/desktop-tauri cargo:clippy +pnpm --filter @memry/desktop-tauri cargo:test +cd apps/desktop-tauri/src-tauri && cargo test --release --features test-helpers --test vault_bench +cd - + +# TS / lint / type +pnpm --filter @memry/desktop-tauri typecheck +pnpm --filter @memry/desktop-tauri lint +pnpm --filter @memry/desktop-tauri test +pnpm --filter @memry/desktop-tauri bindings:check +pnpm --filter @memry/desktop-tauri capability:check +pnpm --filter @memry/desktop-tauri port:audit +pnpm --filter @memry/desktop-tauri command:parity + +# Cold-start smoke: open scratch vault, list notes, write a note, +# verify watcher fires. +pnpm --filter @memry/desktop-tauri db:reset +pnpm --filter @memry/desktop-tauri dev & +DEV_PID=$! +sleep 8 +# Manually exercise the renderer's vault selector against the scratch +# vault path. Verify in dev console: +# - vault_open returns success: true +# - vault_list_notes returns the seeded files +# - touching a file in Finder fires a vault-changed event +kill $DEV_PID +``` + +Expected: every command exits 0. Cold-start smoke completes without errors. + +- [ ] **Step 16.4: Count Rust tests for the acceptance gate** + +```bash +cd apps/desktop-tauri/src-tauri && cargo test --features test-helpers 2>&1 | grep 'test result' +``` + +Spec doesn't quote a numeric Rust-test gate for M3, but the M2 bar of ≥20 should hold. Approximate count after this milestone: + +- `vault_paths_test`: 9 +- `vault_fs_test`: 9 +- `vault_frontmatter_test`: 9 +- `vault_notes_io_test`: 5 +- `vault_preferences_test`: 8 +- `vault_registry_test`: 6 +- `vault_watcher_test`: 4 +- `vault_bench`: 1 +- carry-over from M2 (settings + migrations): ~28 + +Total: ~79. Comfortably above the spec's "≥20 smoke tests" bar. + +- [ ] **Step 16.5: Remove the drag-drop spike telemetry import** + +Open `apps/desktop-tauri/src/main.tsx` and delete the `void listen('vault-drag-drop', ...)` block added in Task 14.3. The smoke is documented in `scripts/drag-drop-smoke.md`; the import was a one-shot verification. + +```bash +git add apps/desktop-tauri/src/main.tsx +git commit -m "m3(spike): remove drag-drop spike telemetry; smoke documented in scripts/drag-drop-smoke.md" +``` + +- [ ] **Step 16.6: Push branch and open PR** + +```bash +git push -u origin m3/vault-fs-and-watcher +``` + +Open the PR titled `m3: Vault FS + file watcher` with body: + +```markdown +## Summary + +- Vault FS module: `paths` (canonicalize + traversal/symlink/hidden-dir guard), `fs` (atomic_write + safe_read + list + sha256 hash), `frontmatter` (serde_yaml_ng parse/serialize with Turkish + multiline YAML round-trip), `notes_io` (high-level read/write with content-hash skip), `preferences` (vault-rooted `.memry/config.json`), `registry` (multi-vault list at `/memry-{device}/vaults.json`), `state` (VaultRuntime + status), `watcher` (notify v6 + 150ms debounce, emits `vault-changed`) +- 18 vault Tauri commands: open, close, get_status, get_current, get_all, switch, remove, get_config, update_config, list_notes, read_note, write_note, delete_note, reveal, reindex (M7-deferred stub) + 5 native commands: shell_open_url, shell_open_path, shell_reveal_in_finder, dialog_choose_folder, dialog_choose_files +- `memry-file://` custom URI scheme handler with vault allowlist, byte-range support, 1×1 transparent PNG fallback for missing images, 403 for outside-vault paths +- Drag-drop path-resolution spike: real macOS WebKit drop paths verified (or documented fallback to `dialog_choose_files`) +- 23 commands swapped from mock to real Rust; `vault_reindex` deferred to M7 with explicit ledger entry; `vault_create` flagged for M5 onboarding refactor +- Runtime e2e smoke (`m3-vault-smoke.spec.ts`) covering open/list/read/write + Turkish round-trip +- 100-note vault scan bench: <500ms (acceptance gate); local Apple-silicon dev target <80ms + +Parent spec: `docs/superpowers/specs/2026-04-24-electron-to-tauri-full-migration-design.md` §M3 +Plan: `docs/superpowers/plans/2026-04-26-m3-vault-fs-and-watcher.md` + +## Acceptance gate + +- [x] `vault_open` scans 100-note test vault in <500ms (`vault_bench`) +- [x] External file edits emit watcher events to renderer (`vault_watcher_test::detects_new_file_within_debounce_window` + manual smoke) +- [x] Frontmatter Turkish/multiline YAML/date round-trip without loss (`vault_frontmatter_test`) +- [x] Atomic write survives mid-write crash simulation (`vault_fs_test::atomic_write_cleans_up_temp_on_failure`) +- [x] Path-traversal + symlink-escape tests fail closed (`vault_paths_test`) +- [x] Tauri drag-drop manual smoke documented (`scripts/drag-drop-smoke.md`) +- [x] Native choose/reveal/open commands fail closed for paths outside vault/app-data roots (`shell_open_path` validates absolute + exists; protocol returns 403) +- [x] Local file protocol spike: image, PDF, media range, missing-image fallback, outside-vault denial all verified +- [x] Renderer integration smoke: open/create/delete reflects in UI (m3-vault-smoke.spec.ts + manual) +- [x] `cargo test` passes (vault tests + carry-over) — `cd apps/desktop-tauri/src-tauri && cargo test --features test-helpers` exits 0 + +## Carry-forward ledger + +1. `@memry/*` occurrences: (was 142 at M1, post-M2 baseline X — fill in actual) +2. Non-test Electron residue: `pnpm --filter @memry/desktop-tauri port:audit` exits 0 +3. M1 non-blocking warnings: still present (notes-tree setState, Radix dialog, ::highlight CSS, large chunk) — none touched by M3 domain +4. Runtime e2e lane: harness exists; 1 spec file (`m3-vault-smoke.spec.ts`) covers the M3 surface; lane gated behind `M3_TEST_VAULT_PATH` env var + +## Test plan + +- [ ] `pnpm --filter @memry/desktop-tauri cargo:test` green +- [ ] `pnpm --filter @memry/desktop-tauri cargo:test --release --test vault_bench` p95 < 500ms +- [ ] `pnpm --filter @memry/desktop-tauri bindings:check` clean +- [ ] `pnpm --filter @memry/desktop-tauri capability:check` exit 0 +- [ ] `pnpm --filter @memry/desktop-tauri command:parity` exit 0 with `vault_reindex`/`vault_create` classified +- [ ] `pnpm --filter @memry/desktop-tauri port:audit` exit 0 +- [ ] Manual: open scratch vault, list notes, write+read a note with Turkish chars, touch a file in Finder, see watcher event in dev console +- [ ] Manual: drag image/PDF/video into window, see real paths in console +- [ ] Manual: shell_open_url opens a browser, shell_reveal_in_finder reveals a path, dialog_choose_folder + dialog_choose_files show pickers +- [ ] Manual: memry-file:// URL renders an image, returns 403 for `/etc/hosts`, returns 1×1 PNG for missing image + +## Risk coverage + +- Risk: macOS FSEvents rename detection edge cases. Mitigation: notify v6 fallback + per-path debounce. The watcher classifies rename as `Modified`, which is the safe upper bound. +- Risk: serde_yaml deprecation. Mitigation: chose `serde_yaml_ng` (active fork) per ecosystem consensus. +- Risk: vault path canonicalization differences (`/private/var/...` vs `/var/...` on macOS). Mitigation: `dunce::canonicalize` everywhere. +- Risk: drag-drop path resolution might fall back to `webkit-fake-url://`. Mitigation: documented fallback uses `dialog_choose_files` already implemented. +``` + +- [ ] **Step 16.7: Land the PR** + +Use `/land-and-deploy` (gstack skill) or manual merge after CI green. Squash-merge per repo convention. + +--- + +## Self-review checklist (plan author) + +- [x] Vault FS module — `fs.rs` atomic_write + safe_read + list + content_hash (Task 4) +- [x] `frontmatter.rs` — serde_yaml_ng parse/serialize with property extraction (Task 5) +- [x] `notes_io.rs` — high-level `read_note_from_disk` / `write_note_to_disk` (Task 6) +- [x] `preferences.rs` — vault-rooted JSON config (Task 7) +- [x] `watcher.rs` — notify with 150ms debounce + `vault-changed` event (Task 10) +- [x] Path normalization + escape guard — `paths.rs` (Task 3) +- [x] Drag-drop path-resolution spike + documented fallback (Task 14) +- [x] Native open/reveal/dialog command set — `shell.rs` + `dialog.rs` (Task 12) +- [x] `memry-file://` protocol — Tauri custom URI scheme with allowlist + range + missing-image fallback (Task 13) +- [x] All commands from spec deliverable list registered: `vault_open`, `vault_close`, `vault_get_current`, `vault_list_notes`, `vault_read_note`, `vault_write_note` (Task 11) +- [x] All renderer-expected commands registered: `vault_get_status`, `vault_get_config`, `vault_update_config`, `vault_get_all`, `vault_switch`, `vault_remove`, `vault_reveal`, `vault_reindex` (Task 11) +- [x] `vault-changed` event with `{path, kind}` payload — `VaultEvent` (Tasks 10, 11) +- [x] 100-note vault scan <500ms bench (Task 16) +- [x] Watcher events external-edit smoke (Task 10 test + Task 16 manual) +- [x] Frontmatter Turkish/multiline YAML/date round-trip (Task 5) +- [x] Atomic write crash simulation (Task 4) +- [x] Path traversal + symlink escape tests (Task 3) +- [x] Renderer integration smoke (Tasks 15, 16) +- [x] `cargo test --package vault` equivalent — single-crate project means `cargo test` runs every vault test plus carry-over (Task 16.4) + +### Intentional deferrals + +| Item | Deferred to | Rationale | +|------|-------------|-----------| +| `vault_reindex` real impl | M7 | Index DB (FTS5 + sqlite-vec) does not exist until M7. M3 ships a stub that returns `{ deferredUntil: 'M7' }`. | +| `vault_create` real impl | M5 | The renderer onboarding flow uses `dialog_choose_folder` + `vault_open` already in M3. The legacy `vault_create` mock survives because the existing onboarding component still references it; M5 removes it during the notes-CRUD refactor. | +| Note-rename detection | M5 | The Electron watcher does delete-add-pair UUID matching for renames. M3 ships only Created/Modified/Deleted; rename detection lives with note CRUD in M5. | +| FTS / properties / tag definitions sync | M7 | Watcher emits the event; cache rebuild lives in M7. | +| PDF/thumbnail rendering | M8.13–M8.14 | Protocol carries the bytes; PDF/thumbnail UIs live with the broader media features. | + +### Open questions for Kaan + +1. The Rust DB stays at `/memry-{device}/data.db` (M2 decision). Electron stored DB at `/.memry/data.db`. Confirm the vault directory does NOT need a per-vault DB (matches M2 architecture). Default assumption: confirmed. +2. Watcher rename detection deferred to M5 (note CRUD owns it). Confirm. +3. `vault_create` mock kept for the onboarding component until M5 (because that's where the flow gets its proper Rust replacement). Confirm. + +--- + +## Post-M3 + +After M3 merges: + +1. Begin M4 (Crypto + Keychain + Auth) per spec §4 M4. Start with the 1-day security-framework subspike before opening the implementation plan. +2. M5 (Notes CRUD + BlockNote + CRDT) blocks on M3 + M4 both being merged. Plan that worktree off `main` after both PRs land. +3. The runtime e2e lane added in Task 15.6 becomes the default lane for M5 acceptance — extend it with note-rename + concurrent-edit specs at that time. diff --git a/prompts/m3/README.md b/prompts/m3/README.md new file mode 100644 index 000000000..fb47766b3 --- /dev/null +++ b/prompts/m3/README.md @@ -0,0 +1,125 @@ +# M3 — Vault FS + File Watcher / Phase Prompts + +Her phase için ayrı prompt. Temiz session'da tek tek çalıştır. Prior phase'ler tamamlanmadan sonrakine geçme. + +## Worktree + +M3 ayrı worktree'de yürütülür (user preference — feedback_worktree.md). M2 PR `main`'e merge edildikten sonra: + +```bash +cd /Users/h4yfans/sideproject/memry-worktrees/spike-tauri-m2 +git worktree add ../spike-tauri-m3 -b m3/vault-fs-and-watcher main +cd ../spike-tauri-m3 +mkdir -p ~/memry-test-vault-m3/notes ~/memry-test-vault-m3/journal ~/memry-test-vault-m3/attachments +``` + +Tüm phase'ler `../spike-tauri-m3` altında çalışır. Prompt'lar bu yolu default olarak kullanır. + +## Çalıştırma sırası + +| Phase | Prompt | Görev | Plan Task | Durum | +|-------|--------|-------|-----------|-------| +| A | `m3-phase-a-foundation.md` | Cargo deps + AppError vault variants + `vault/` module skeleton + `paths.rs` (TDD) | 1-3 | ⏳ | +| B | `m3-phase-b-vault-core-io.md` | `fs.rs` atomic write + safe read + list, `frontmatter.rs` parse/serialize, `notes_io.rs` round-trip (full TDD) | 4-6 | ⏳ | +| C | `m3-phase-c-preferences-registry.md` | `preferences.rs` per-vault JSON + `registry.rs` multi-vault list (TDD) | 7-8 | ⏳ | +| D | `m3-phase-d-watcher-runtime-state.md` | `watcher.rs` notify+debounce, `state.rs` VaultRuntime, `AppState` extension (TDD) | 10, 9 | ⏳ | +| E | `m3-phase-e-tauri-commands.md` | `commands/vault.rs` (13 commands) + `commands/shell.rs` + `commands/dialog.rs` + capabilities | 11-12 | ⏳ | +| F | `m3-phase-f-protocol-and-dragdrop.md` | `memry-file://` URI scheme handler + drag-drop path-resolution spike | 13-14 | ⏳ | +| G | `m3-phase-g-bindings-renderer-bench-pr.md` | Specta bindings regen, mock-swap, runtime e2e smoke, 100-note bench, acceptance gate, PR | 15-16 | ⏳ | + +## TDD metodoloji (zorunlu her phase için) + +**Her implementasyon adımı RED-GREEN-REFACTOR disiplinine bağlı:** + +1. **RED:** Önce failing test yaz (cargo test veya vitest — duruma göre). +2. Test koş → **FAIL** beklenir. Fail mesajı mantıklı mı doğrula. +3. **GREEN:** Minimum kod ile test'i geç. +4. Test koş → **PASS** doğrula. +5. **REFACTOR:** Duplication varsa temizle, test hâlâ PASS. +6. Commit. + +**TDD-appropriate phase'ler (zorunlu):** +- **Phase A** (Task 3 paths.rs) — RED-GREEN, 8 path-safety testleri +- **Phase B** (Tasks 4-6 fs/frontmatter/notes_io) — TAM TDD; 9+9+5 = 23 test +- **Phase C** (Tasks 7-8 preferences/registry) — TAM TDD; 8+6 = 14 test +- **Phase D** (Tasks 10 watcher) — TDD; 4 watcher test (multi_thread) +- **Phase G** (Task 16 bench) — bench-as-test, RED ile başla + +**TDD uygulanması mekanik olan phase'ler (komut/wiring scaffold):** +- Phase E (commands), Phase F (protocol + spike) +- Bu phase'lerde test yerine **verification-before-completion disiplini**: + - Her komut sonrası `cargo check` + `cargo clippy -- -D warnings` + - Her dosya değişikliğinde `cargo test --features test-helpers` (carry-over kırılmasın) + - Manuel smoke (e.g. `pnpm dev` + Finder drop) bu phase'lerde zorunlu + - Phase sonunda full check matrix (lint/typecheck/test/cargo:test/bindings:check) + +## Genel kurallar (her prompt bunu inherit eder) + +1. **Worktree kökü:** `/Users/h4yfans/sideproject/memry-worktrees/spike-tauri-m3` +2. **Branch:** `m3/vault-fs-and-watcher` +3. **Asla dokunma:** `apps/desktop/**`, `apps/sync-server/**`, `packages/**`, `docs/superpowers/specs/**`, `docs/superpowers/plans/**`, `docs/spikes/**` (okuma OK, yazma hayır). M2'de kalan mock'lar yerinde kalır — M3 sadece Phase G'de `vault_*`, `shell_*`, `dialog_*` komutlarını gerçek invoke'a çevirir; `vault_reindex` ve `vault_create` mock olarak kalır (M7/M5 deferred). +4. **Kod standardı (Rust):** `rustfmt` default, `clippy -- -D warnings` zorunlu. `unwrap()`/`expect()` command path'inde YASAK; `state.rs` mutex poison handling `unwrap_or_else(|p| p.into_inner())` pattern kullanır. Vault `fs::*` çağrıları HER ZAMAN `paths::resolve_*` ile başlar — bypass yok. +5. **Kod standardı (TS):** Prettier (single quotes, no semi, 100 char, no trailing comma), ESLint flat config, named exports, strict TS. `console.log` yasak — sadece e2e spec'lerinde `console.info` for spike telemetry tolere edilir (Phase F'de import edilir, Phase G'de kaldırılır). +6. **Rust error handling:** Her command `Result` döner. `AppError` Phase A'da Vault/PathEscape/Io variant'ları ile genişletilir. `From` → `AppError::Io` (M2'deki `Internal` mapping'i değiştirilir). `From` ve `From` Phase A'da eklenir. +7. **Specta hygiene:** Her vault struct'ta `#[derive(Debug, Clone, Serialize, Deserialize, specta::Type)]` + `#[serde(rename_all = "camelCase")]`. Phase G'deki bindings generator bu canonical isimleri bekler. +8. **Path discipline:** `tokio::fs` veya `std::fs` çağrıları SADECE `vault/fs.rs`, `vault/preferences.rs`, ve `vault/registry.rs` içinde. Diğer modüller bu modülleri çağırır — escape guard bypass'lanmaz. +9. **Commit message format:** `m3(): ` — scope plan'dan alınır (deps, vault, commands, protocol, spike, renderer, bench, devx). +10. **PR stratejisi:** Tüm phase'ler aynı branch'e commit. M3 bittiğinde Phase G sonunda tek PR açılır. +11. **Plan dosyası:** `docs/superpowers/plans/2026-04-26-m3-vault-fs-and-watcher.md` — phase prompt'ları bu dosyaya referans verir, içerik yinelenmez. +12. **Spec dosyası:** `docs/superpowers/specs/2026-04-24-electron-to-tauri-full-migration-design.md` — mimari kararlar için otorite (M3 bölümü §4, cross-cutting §5). +13. **Predecessor:** M2 PR (`docs/superpowers/plans/2026-04-25-m2-db-schemas-migrations.md`) `main`'e merge edilmiş olmalı. Phase A pre-flight bunu doğrular. + +## Phase handoff + +Her phase sonunda şu komutları çalıştır: + +```bash +cd /Users/h4yfans/sideproject/memry-worktrees/spike-tauri-m3 +git log --oneline -10 +git status --short +pnpm --filter @memry/desktop-tauri cargo:check +pnpm --filter @memry/desktop-tauri cargo:clippy +cd apps/desktop-tauri/src-tauri && cargo test --features test-helpers 2>&1 | tail -10 && cd - +pnpm --filter @memry/desktop-tauri typecheck +``` + +Ve kullanıcıya şunu rapor et: + +``` +Phase complete. +Tasks covered: +Commits: (..) +Rust tests: (delta vs prior phase: +N) +Next: Phase — +Blockers: +``` + +## Emergency stop + +Phase içinde bir task patlak verirse: + +1. Durdur, sorunu özetle. +2. Root cause'u `superpowers:systematic-debugging` skill ile analiz et. +3. Plan'da yazan trip-wire'lardan biri tetiklendi mi kontrol et: + - `serde_yaml_ng` parse hatası → orijinal Electron `gray-matter` output'unu byte-byte karşılaştır. + - notify v6 platform fark → `macos_fsevents` feature aktif mi? + - Path canonical mismatch (`/private/var/...` vs `/var/...`) → her yerde `dunce::canonicalize` kullanıldı mı? + - Watcher debounce flake → test `multi_thread` flavor + 100ms warm-up sleep var mı? +4. Symlink loop / DOS test'inde hang → `list_supported_files` symlink skip ediyor mu? +5. Kullanıcıya rapor et ve onay bekle. + +Plan dışına çıkma. "Bu fikre düştüm, şunu da ekleyeyim" yapma. Scope creep = budget creep. Özellikle: + +- Yeni vault command ekleme (spec onayı olmadan; M3 surface = 13 vault + 3 shell + 2 dialog) +- M3'te rename detection eklemek (Plan defers to M5) +- M3'te FTS / embedding rebuild eklemek (Plan defers to M7 — `vault_reindex` stub returns `{ deferredUntil: 'M7' }`) +- M3'te `vault_create` real impl (Plan defers to M5 onboarding refactor) +- Yeni dep ekleme (Phase A'nın allow-listesi dışında: notify, serde_yaml_ng, mime_guess, sha2, dunce, tauri-plugin-dialog, nanoid, anyhow only) +- Pool / cache / async-watcher refactoru — M3 minimal Tokio mpsc + `notify::Watcher` + `parking_lot`/`std::sync::Mutex` + +## Kritik referanslar + +- **Plan self-review tablosu**: `docs/superpowers/plans/2026-04-26-m3-vault-fs-and-watcher.md` sonunda "Intentional deferrals" tablosu var. `vault_reindex` (M7), `vault_create` (M5), note-rename detection (M5), FTS rebuild (M7), PDF/thumbnail UI (M8.13–14) M3'te **yazılmaz**. +- **MEMORY.md gotchas**: `~/.claude/projects/.../memory/MEMORY.md` — özellikle "Pre-existing type errors in test files" ve "Migrations are hand-written since 0020" notları M3 sırasında devreye girer. +- **Pre-production app**: No backward-compat needed. Phase F'de SHA-256 content_hash kullanır (Electron'un djb2 hash'i pre-production free swap). +- **Spec §5.7 Security**: `capabilities/default.json` düz grant — Phase E `tauri-plugin-dialog` ekler, `tauri-plugin-shell` zaten M2'den var. Phase F CSP'ye sadece `memry-file:` ekler — third-party host genişletilmez. diff --git a/prompts/m3/m3-phase-a-foundation.md b/prompts/m3/m3-phase-a-foundation.md new file mode 100644 index 000000000..6109b894f --- /dev/null +++ b/prompts/m3/m3-phase-a-foundation.md @@ -0,0 +1,186 @@ +# M3 Phase A — Foundation (Deps + AppError + Module Skeleton + Paths, TDD) + +Temiz session prompt. **Bu phase Task 3 için TDD gerektirir** — `paths.rs` baştan sona RED-GREEN. + +--- + +## PROMPT START + +You are implementing **Phase A of Milestone M3** for Memry's Electron→Tauri migration. This phase lands the vault FS foundation: new Cargo deps, extended `AppError` variants for filesystem context, the `vault/` module skeleton (8 stubbed submodules), and the first real implementation — `vault/paths.rs` with canonicalize + escape guard. + +### Context + +**Worktree:** `/Users/h4yfans/sideproject/memry-worktrees/spike-tauri-m3` +**Branch:** `m3/vault-fs-and-watcher` (must already exist — see README worktree setup) +**Parent spec:** `docs/superpowers/specs/2026-04-24-electron-to-tauri-full-migration-design.md` (M3 section §4, cross-cutting §5) +**Implementation plan:** `docs/superpowers/plans/2026-04-26-m3-vault-fs-and-watcher.md` +**Prompts README:** `prompts/m3/README.md` + +Memry: desktop notes app, Electron→Tauri migration, pre-production, no backward compat. M1 landed the Tauri skeleton with mock IPC; M2 wired SQLite + the settings IPC slice. M3 lands the vault file tree — `.md` IO, YAML frontmatter, multi-vault registry, `notify` watcher, the full vault/shell/dialog command surface, and the `memry-file://` URI scheme. This phase opens the milestone with deps + `paths.rs`. + +### Prerequisite verification + +```bash +cd /Users/h4yfans/sideproject/memry-worktrees/spike-tauri-m3 +git rev-parse --abbrev-ref HEAD # expect: m3/vault-fs-and-watcher +git log --oneline main | head -10 # expect M2 commits ending with `m2(devx): add MEMRY_DEVICE=A/B dev scripts` +test -d apps/desktop-tauri/src-tauri/src +test -f apps/desktop-tauri/src-tauri/Cargo.toml +test -f apps/desktop-tauri/src-tauri/src/error.rs # M2 created this +test -f apps/desktop-tauri/src-tauri/src/app_state.rs # M2 created this +pnpm --filter @memry/desktop-tauri cargo:check # must exit 0 on M2 baseline +pnpm --filter @memry/desktop-tauri cargo:clippy # must exit 0 +cd apps/desktop-tauri/src-tauri && cargo test --features test-helpers 2>&1 | tail -3 && cd - +# expect: test result ok, all M2 carry-over tests passing (~28) +pnpm --filter @memry/desktop-tauri bindings:check # must exit 0 +test -d ~/memry-test-vault-m3 # scratch vault for later phases (created in README setup) +``` + +If any fails, STOP and report. Do not improvise the worktree, branch, or M2 baseline. + +### Your scope + +Execute **Tasks 1, 2, 3** from the plan: + +- **Task 1:** Append M3 deps to `[dependencies]` in `apps/desktop-tauri/src-tauri/Cargo.toml`: + - `notify = { version = "6.1", default-features = false, features = ["macos_fsevents"] }` + - `serde_yaml_ng = "0.10"` + - `mime_guess = "2.0"` + - `sha2 = "0.10"` + - `dunce = "1.0"` + - `tauri-plugin-dialog = "2"` + +- **Task 2:** Extend `AppError` enum + scaffold `vault/` module: + - Add `Vault(String)`, `PathEscape(String)`, `Io(String)` variants to `AppError` in `src/error.rs`. + - REPLACE existing `From` impl: it currently maps to `Internal`; remap to `AppError::Io` (filesystem context surfaces IO errors everywhere — vault layer needs them typed). + - Add `From` → `AppError::Validation(format!("yaml: {err}"))`. + - Add `From` → `AppError::Vault(format!("watcher: {err}"))`. + - Create `src/vault/mod.rs` with 8 `pub mod` declarations (paths, fs, frontmatter, notes_io, preferences, registry, state, watcher) + commented-out re-exports (re-enabled in Phase D Task 9). + - Stub each submodule with a one-line comment so the tree compiles between tasks. + - Wire `pub mod vault;` into `src/lib.rs` near the existing `pub mod` declarations. + +- **Task 3:** Implement `vault/paths.rs` (canonicalize + traversal/symlink/hidden-dir guard) full TDD: + - Write failing test file `tests/vault_paths_test.rs` with **9 tests** (rejects_dotdot_escape, rejects_absolute_outside_vault, allows_normal_relative_path, rejects_symlink_escape, rejects_hidden_dot_memry_directory, rejects_unsupported_extension, allows_supported_extensions, to_relative_path_normalizes_separators, to_relative_path_rejects_outside_vault). + - Register `[[test]] name = "vault_paths_test" required-features = ["test-helpers"]` in `Cargo.toml`. + - Run RED → unresolved imports. + - Implement `paths.rs` per plan Step 3.4 (uses `dunce::canonicalize`, supports `resolve_in_vault`, `resolve_supported`, `to_relative_path`, `is_markdown`, `normalize_relative`). + - Run GREEN → 9 passed. + +### Methodology — TDD mandatory for Task 3 + +1. **Invoke `superpowers:using-superpowers` and `superpowers:test-driven-development`** first. +2. **Task 1 (deps):** Not TDD — `cargo check` is the verification. Add deps + run check + commit. +3. **Task 2 (errors + skeleton):** Not TDD in the RED-GREEN sense. Verify with `cargo check && cargo clippy -- -D warnings` after each substep. The stubbed submodules must compile — `cargo check` will warn about unused modules, that is OK. +4. **Task 3 (paths.rs):** + - Plan Step 3.1 lists every test verbatim. Copy the test file as written; do NOT skip the symlink test (it uses `std::os::unix::fs::symlink` and must run on macOS). + - Step 3.2: register the `[[test]]` block. + - Step 3.3: RED → `cargo test --features test-helpers --test vault_paths_test` must fail with unresolved imports for `paths`, `resolve_in_vault`, `resolve_supported`, `to_relative_path`. Confirm before moving to Step 3.4. + - Step 3.4: implement `paths.rs` per plan verbatim. + - Step 3.5: re-run → 9 passed. + - Step 3.6: commit per plan verbatim message: `m3(vault): paths.rs canonicalize + traversal/symlink/hidden-dir guard`. + +### Critical gotchas + +1. **`From` REPLACE, not ADD:** M2's `error.rs` has an `impl From for AppError` returning `Internal`. Vault FS surfaces IO errors all over — Phase A maps them to `Io`. The plan uses the word "replace" deliberately. Adding a second impl will fail to compile (duplicate `From`). Edit, don't append. +2. **Submodule stubs are required:** `cargo check` after Step 2.4 expects 8 files at `src/vault/{paths,fs,frontmatter,notes_io,preferences,registry,state,watcher}.rs` each with a comment line. If any is missing, `cargo check` errors with `error[E0583]: file not found for module`. The bash `for name in ...; do echo "//! Stubbed in Task 2; populated in later tasks." > apps/desktop-tauri/src-tauri/src/vault/$name.rs; done` loop in Step 2.4 is the canonical setup. +3. **Comment out re-exports until Phase D:** `mod.rs` declares `pub mod fs; pub mod frontmatter; ...` but the `pub use frontmatter::{NoteFrontmatter, ParsedNote}; ...` block must be commented. Phase D (Task 9) re-enables them once the types exist. Leaving them uncommented in Phase A breaks `cargo check` because the symbols don't exist yet. +4. **`dunce::canonicalize` on macOS:** macOS resolves symlinks differently — `/var` vs `/private/var`. The plan uses `dunce::canonicalize` everywhere, including for the vault root + the joined candidate path, so `starts_with` comparisons are byte-stable. Don't substitute `std::fs::canonicalize` even if it "looks fine" locally — symlink test will flake on different macOS major versions. +5. **`resolve_in_vault` must handle non-existing leaf:** `atomic_write` (Phase B) calls `resolve_in_vault` for paths that don't exist yet. The plan handles this in Step 3.4: if `joined.exists()` then canonicalize the full path, else canonicalize the parent and re-attach the leaf. This is critical for the "write a new file" path-safety case. +6. **Hidden-dir check uses `.memry`, not `.git`:** The escape guard rejects `.memry/data.db` because that is the Electron-era reserved app folder. `.git` and other generic hidden dirs are skipped at *list* time (`fs.rs::list_supported_files`, Phase B), not rejected by `resolve_in_vault`. +7. **Symlink test is unix-specific:** `tests/vault_paths_test.rs` uses `std::os::unix::fs as unix_fs;` and `unix_fs::symlink(...)`. Plan assumes macOS dev. If cargo test runs on a non-unix host the test won't compile — guard with `#[cfg(unix)]` only if tests are run cross-platform; M3 dev is macOS-only so the unconditional import is fine. +8. **`SUPPORTED_EXT` allowlist:** `md, markdown, png, jpg, jpeg, gif, webp, svg, pdf, mp3, wav, m4a, ogg, mp4, mov, webm`. Match exactly. The plan's Step 3.4 lists these; the test `allows_supported_extensions` enumerates 11 of them — ensure both lists agree. + +### Constraints + +- **No scope creep:** Do not implement `fs.rs`, `frontmatter.rs`, or any other vault submodule in Phase A. Stubs only. Phase B-D handle them. +- **No additional crates beyond Phase A list:** notify, serde_yaml_ng, mime_guess, sha2, dunce, tauri-plugin-dialog. `nanoid` and `anyhow` come in Phases B and F respectively. Do NOT pre-add them. +- **No new error variants beyond the 3 listed:** Vault, PathEscape, Io. Do not invent `Permission`, `Locked`, `Encoding`, etc. — Phase B's `notes_io.rs` and Phase D's `state.rs` reuse existing variants (`NotFound`, `Validation`). +- **`AppError` ordering:** Insert new variants AFTER `Validation(String)` per plan Step 2.1. Don't re-sort the enum — that would break specta-generated TS bindings ordering and force a regen with no value. +- **Rust style:** `rustfmt` before commit. `cargo clippy -- -D warnings` must be clean at Task 1, 2, 3 boundaries. The unused-module warnings after Task 2.4 are acceptable (they go away after Task 3 implements `paths.rs`). + +### Acceptance criteria (Phase A done when all pass) + +```bash +cd /Users/h4yfans/sideproject/memry-worktrees/spike-tauri-m3 + +# Files exist +test -f apps/desktop-tauri/src-tauri/src/vault/mod.rs +for name in paths fs frontmatter notes_io preferences registry state watcher; do + test -f apps/desktop-tauri/src-tauri/src/vault/$name.rs || { echo "MISSING vault/$name.rs"; exit 1; } +done +test -f apps/desktop-tauri/src-tauri/tests/vault_paths_test.rs + +# Deps present +grep -q '^notify' apps/desktop-tauri/src-tauri/Cargo.toml +grep -q '^serde_yaml_ng' apps/desktop-tauri/src-tauri/Cargo.toml +grep -q '^mime_guess' apps/desktop-tauri/src-tauri/Cargo.toml +grep -q '^sha2' apps/desktop-tauri/src-tauri/Cargo.toml +grep -q '^dunce' apps/desktop-tauri/src-tauri/Cargo.toml +grep -q '^tauri-plugin-dialog' apps/desktop-tauri/src-tauri/Cargo.toml + +# AppError variants +grep -q 'Vault(String)' apps/desktop-tauri/src-tauri/src/error.rs +grep -q 'PathEscape(String)' apps/desktop-tauri/src-tauri/src/error.rs +grep -q 'Io(String)' apps/desktop-tauri/src-tauri/src/error.rs +grep -q 'From' apps/desktop-tauri/src-tauri/src/error.rs +grep -q 'From' apps/desktop-tauri/src-tauri/src/error.rs + +# vault module wired +grep -q 'pub mod vault' apps/desktop-tauri/src-tauri/src/lib.rs + +# Re-exports still commented (Phase D enables them) +grep -E '^//.*pub use frontmatter' apps/desktop-tauri/src-tauri/src/vault/mod.rs + +# Test registered +grep -q 'name = "vault_paths_test"' apps/desktop-tauri/src-tauri/Cargo.toml + +# Rust compiles + clippy clean +pnpm --filter @memry/desktop-tauri cargo:check +pnpm --filter @memry/desktop-tauri cargo:clippy + +# Tests pass — paths_test green + M2 carry-over still green +cd apps/desktop-tauri/src-tauri && cargo test --features test-helpers --test vault_paths_test 2>&1 | tail -3 +# Expect: test result: ok. 9 passed +cd apps/desktop-tauri/src-tauri && cargo test --features test-helpers 2>&1 | tail -3 +# Expect: total ~37 passed (9 new + ~28 carry-over). 0 failed. + +# Commits +cd /Users/h4yfans/sideproject/memry-worktrees/spike-tauri-m3 +git log --oneline | grep -cE 'm3\((deps|vault)\)' # expect ≥ 3 (1 deps + 2 vault) + +# Electron / packages untouched +git diff --name-only main..HEAD -- apps/desktop/ apps/sync-server/ packages/ docs/superpowers/specs/ docs/superpowers/plans/ | wc -l +# expect 0 +``` + +### When done + +Report to user: + +``` +Phase A complete. +Tasks covered: 1, 2, 3 +Commits: (..) +Rust tests: 9 new (vault_paths_test) + ~28 M2 carry-over = ~37 passed +Verification: + - cargo check: clean + - cargo clippy -- -D warnings: clean + - cargo test --features test-helpers: ~37 passed, 0 failed + - Electron/packages/specs/plans untouched: 0 files + +Next: Phase B — prompts/m3/m3-phase-b-vault-core-io.md +Blockers: +``` + +If blocker: do not guess. Invoke `superpowers:systematic-debugging`. Check plan §"Risk coverage" + README §"Emergency stop" trip-wires. Report + wait for approval. + +### Ready + +1. Invoke `superpowers:using-superpowers` and `superpowers:test-driven-development`. +2. Read plan Tasks 1, 2, 3 fully (lines 110–597 of the plan file). +3. Run prerequisite verification. Report results. +4. Task 1: append deps → `cargo check` → commit `m3(deps): add notify, serde_yaml_ng, mime_guess, sha2, dunce, dialog plugin`. +5. Task 2: extend `AppError` + create `vault/mod.rs` + 8 stubs + wire into `lib.rs` → `cargo check` → commit `m3(vault): scaffold module + extend AppError with Vault/PathEscape/Io`. +6. Task 3: full RED-GREEN — failing test → impl `paths.rs` → 9 passed → commit `m3(vault): paths.rs canonicalize + traversal/symlink/hidden-dir guard`. + +## PROMPT END diff --git a/prompts/m3/m3-phase-b-vault-core-io.md b/prompts/m3/m3-phase-b-vault-core-io.md new file mode 100644 index 000000000..f4e2bcb61 --- /dev/null +++ b/prompts/m3/m3-phase-b-vault-core-io.md @@ -0,0 +1,207 @@ +# M3 Phase B — Vault Core IO (fs.rs + frontmatter.rs + notes_io.rs, full TDD) + +Temiz session prompt. **Bu phase TAM TDD** — her modül RED-GREEN-REFACTOR. 23 test toplam. + +--- + +## PROMPT START + +You are implementing **Phase B of Milestone M3** for Memry's Electron→Tauri migration. This phase fleshes out the three core IO modules of the vault layer: atomic filesystem ops + SHA-256 hash, YAML frontmatter parse/serialize with Turkish + multiline-YAML round-trip, and high-level note IO with content-hash skip. + +### Context + +**Worktree:** `/Users/h4yfans/sideproject/memry-worktrees/spike-tauri-m3` +**Branch:** `m3/vault-fs-and-watcher` +**Plan:** `docs/superpowers/plans/2026-04-26-m3-vault-fs-and-watcher.md` +**Spec:** `docs/superpowers/specs/2026-04-24-electron-to-tauri-full-migration-design.md` (§4 M3, §5 cross-cutting) +**Prompts README:** `prompts/m3/README.md` + +Phase A landed deps + `AppError` extensions + `vault/` module skeleton + `paths.rs` (9 tests). Phase B implements the three modules that build on `paths.rs`: `fs.rs`, `frontmatter.rs`, `notes_io.rs`. + +### Prerequisite verification + +```bash +cd /Users/h4yfans/sideproject/memry-worktrees/spike-tauri-m3 +git rev-parse --abbrev-ref HEAD # expect: m3/vault-fs-and-watcher + +# Phase A complete +test -f apps/desktop-tauri/src-tauri/src/vault/paths.rs +test -f apps/desktop-tauri/src-tauri/tests/vault_paths_test.rs +grep -q 'Vault(String)' apps/desktop-tauri/src-tauri/src/error.rs +grep -q 'PathEscape(String)' apps/desktop-tauri/src-tauri/src/error.rs +grep -q 'Io(String)' apps/desktop-tauri/src-tauri/src/error.rs +grep -q '^notify' apps/desktop-tauri/src-tauri/Cargo.toml +grep -q '^serde_yaml_ng' apps/desktop-tauri/src-tauri/Cargo.toml +grep -q '^sha2' apps/desktop-tauri/src-tauri/Cargo.toml +grep -q '^dunce' apps/desktop-tauri/src-tauri/Cargo.toml + +# All Phase A + M2 tests still green +pnpm --filter @memry/desktop-tauri cargo:check +pnpm --filter @memry/desktop-tauri cargo:clippy +cd apps/desktop-tauri/src-tauri && cargo test --features test-helpers 2>&1 | tail -3 +# expect: ~37 passed, 0 failed (28 M2 carry-over + 9 paths_test) + +# Phase A commits present +cd /Users/h4yfans/sideproject/memry-worktrees/spike-tauri-m3 +git log --oneline | grep -cE 'm3\((deps|vault)\)' +# expect: ≥ 3 (1 deps + 2 vault commits) +``` + +If any fails, STOP. Phase A must complete before Phase B starts. + +### Your scope + +Execute **Tasks 4, 5, 6** from the plan in this order. Each is a full RED-GREEN cycle. + +- **Task 4 — `vault/fs.rs`** (atomic write + safe read + list + content_hash): + - Add `nanoid = "0.4"` to `[dependencies]` (used by `atomic_write` for temp-file suffix). + - Write 9 failing tests in `tests/vault_fs_test.rs`: + - `atomic_write_creates_file`, `atomic_write_replaces_existing_file`, `atomic_write_creates_parent_dirs`, `atomic_write_cleans_up_temp_on_failure` (rename-fails-leaves-no-temp), `safe_read_returns_none_for_missing`, `safe_read_returns_content_for_existing`, `list_supported_files_skips_hidden_and_unsupported`, `content_hash_is_stable_for_same_content`, `content_hash_differs_for_different_content`. + - Register `[[test]] name = "vault_fs_test" required-features = ["test-helpers"]`. + - Implement `fs.rs` per plan Step 4.4: `atomic_write` (temp-then-rename + cleanup on fail), `safe_read` (`Ok(None)` for missing), `read_required`, `delete_file`, `list_supported_files` (DFS, skip dotfiles + `.memry/` + symlinks + unsupported extensions), `content_hash` (SHA-256 hex 64 chars), `is_supported_attachment`. + +- **Task 5 — `vault/frontmatter.rs`** (parse / serialize / property extraction): + - Write 9 failing tests in `tests/vault_frontmatter_test.rs`: + - `parses_minimal_frontmatter`, `auto_generates_missing_required_fields`, `extracts_title_from_filename_when_missing`, `turkish_chars_roundtrip_byte_identical`, `multiline_yaml_string_roundtrip`, `date_field_preserved_as_string`, `tags_normalized_to_vec_strings`, `preserves_non_reserved_properties_through_roundtrip`, `extract_properties_skips_reserved_keys`. + - Register `[[test]] name = "vault_frontmatter_test" required-features = ["test-helpers"]`. + - Implement `frontmatter.rs` per plan Step 5.4: `NoteFrontmatter` struct (id/title/created/modified/tags/aliases/emoji/local_only/properties + `#[serde(flatten)] extra`), `ParsedNote` struct, `parse_note(raw, file_path)`, `serialize_note(fm, content)`, `create_frontmatter(title, tags)`, `extract_properties` method, `RESERVED_KEYS` const = `["id","title","created","modified","tags","aliases","emoji","localOnly","properties"]`. + +- **Task 6 — `vault/notes_io.rs`** (high-level read/write): + - Write 5 failing tests in `tests/vault_notes_io_test.rs`: + - `write_then_read_roundtrip`, `read_returns_none_for_missing_path`, `read_auto_repairs_missing_frontmatter_and_writes_back`, `write_skips_no_op_when_hash_matches`, `read_rejects_path_traversal`. + - Register `[[test]] name = "vault_notes_io_test" required-features = ["test-helpers"]`. + - Implement `notes_io.rs` per plan Step 6.4: `NoteOnDisk` struct (relative_path/content_hash), `ReadNoteResult` struct (parsed/abs_path/content_hash), `read_note_from_disk(vault_root, rel)`, `write_note_to_disk(vault_root, rel, fm, content)`, `delete_note_from_disk(vault_root, rel)`. Auto-repair logic: if `parsed.was_modified`, write the canonical form back to disk. No-op skip: compute hash of new content, compare to disk hash; if equal, skip the rename. + +### Methodology — TDD mandatory for all 3 tasks + +1. **Invoke `superpowers:using-superpowers` and `superpowers:test-driven-development`** first. +2. **Three full RED-GREEN cycles. One commit per task.** +3. For each task: + - Step X.1: write the test file verbatim from the plan (lines listed below). + - Step X.2: register the `[[test]]` block in `Cargo.toml`. + - Step X.3: run `cargo test --features test-helpers --test ` → must FAIL with "unresolved import" / "no function named ...". Confirm RED. + - Step X.4: implement the module per plan verbatim. + - Step X.5 (Task 4 only): add the `nanoid` dep — do this BEFORE `cargo check` post-impl, otherwise the macro fails to resolve. + - Step X.6: re-run test → all PASS. + - Step X.7: `cargo test --features test-helpers` (no `--test` filter) → no regression in carry-over. + - Step X.8: commit per plan verbatim message. + +**Test source line ranges in plan (read them VERBATIM, do not paraphrase):** +- Task 4 test file: plan lines ~609–716 +- Task 4 impl file: plan lines ~738–900 +- Task 5 test file: plan lines ~941–1032 +- Task 5 impl file: plan lines ~1054–1300+ (continues into Task 5 detail block) +- Task 6 test file: plan lines ~1452–1539 +- Task 6 impl file: plan lines ~1550–1690 (read continues from line 1690 of plan) + +### Critical gotchas + +1. **`nanoid` dep order:** `atomic_write` uses `nanoid::nanoid!(12)` at compile time. Add `nanoid = "0.4"` to `Cargo.toml` BEFORE running `cargo check` on the new `fs.rs` — otherwise you'll see `error[E0433]: failed to resolve: use of undeclared crate`. Plan Step 4.5 covers this; don't skip. +2. **Atomic write cleanup branch is critical:** Plan Step 4.4's `atomic_write` uses an `async` block + `match` — if `Err`, unconditionally `let _ = fs::remove_file(&temp_path).await;` then return the error. The test `atomic_write_cleans_up_temp_on_failure` proves no `.tmp.` files leak when the rename fails (target is a directory). Do not factor this into a `?`-chain — the cleanup must run on the failure branch regardless of which step failed. +3. **`safe_read` distinguishes NotFound from other IO errors:** `Ok(None)` for `ErrorKind::NotFound`, else `Err(AppError::Io(...))` via `From` (Phase A remapped this to `Io`, not `Internal`). Plan Step 4.4 handles this in 3 branches; reproduce exactly. +4. **`list_supported_files` must skip symlinks:** Even though `paths::resolve_in_vault` rejects symlink targets, the *list walk* skips symlinks entirely so a symlink loop can't DOS the scan. Use `metadata.file_type().is_symlink()` BEFORE recursing or pushing to output. Plan Step 4.4 guards this; the tests don't exercise it directly but the watcher Phase D depends on the contract. +5. **`list_supported_files` extension check:** The plan calls `paths::resolve_supported(&canonical_root, &format!("dummy.{lower_ext}"))` to validate the extension. This is a hack — it builds a fake path just to reuse the allowlist. Do NOT replace with a separate const; the test relies on `resolve_supported`'s allowlist behavior matching `list_supported_files`. The fallback `paths::is_markdown(&path) || is_supported_attachment(&lower_ext)` covers edge cases. +6. **`serialize_note` bumps `modified`:** Plan Step 5.4 explicitly sets `modified: current_iso()` in `serialize_note`. The `turkish_chars_roundtrip_byte_identical` test compares parsed-after-write content but NOT byte-for-byte — title and body must match, but `modified` will differ from input. Do not skip this bump. +7. **`extra` field with `#[serde(flatten)]`:** This is what catches non-reserved frontmatter keys like `status: active` and `priority: 3`. The serializer iterates `out.extra` and writes any keys not already in the reserved set. Plan Step 5.4 emits these AFTER the reserved keys; preserve order. +8. **`RESERVED_KEYS` casing:** Use `"localOnly"` not `"local_only"`. The struct field is `local_only` with `#[serde(rename_all = "camelCase")]` so YAML serializes as `localOnly`. The `RESERVED_KEYS` array must match the serialized casing. +9. **`extract_title_from_path` titlecase:** `extract_title_from_path("notes/my-cool-thought.md")` returns `"My Cool Thought"` — split on `-`/`_`, capitalize first letter of each word. Test `extracts_title_from_filename_when_missing` verifies this. +10. **`create_frontmatter` test stability:** Tests fix `fm.id = "fixed-id-1"` after `create_frontmatter` returns. Don't make `id` non-public — keep it as `pub id: String`. The test sets it directly. +11. **`write_skips_no_op_when_hash_matches`:** Compute SHA-256 of the about-to-write serialized content. If it matches the on-disk hash (read-then-hash), return the existing `NoteOnDisk` without rewriting. The test asserts `first.content_hash == second.content_hash`. Plan Step 6.4 handles this; read carefully and replicate. +12. **`read_auto_repairs_missing_frontmatter_and_writes_back`:** When `parsed.was_modified`, `read_note_from_disk` writes the canonical form back so the next read is stable. The test reads a plain `"no fm here\n"` file and asserts the on-disk file now starts with `"---\n"`. The `parsed.was_modified` check after `parse_note` is the trigger. +13. **`read_rejects_path_traversal`:** Calls `read_note_from_disk(vault.path(), "../escape.md")`. `paths::resolve_in_vault` errors with `PathEscape`. The error must propagate verbatim — don't wrap it in `Vault` or `Validation`. +14. **`tokio::test` flavor:** Phase B's tests don't need `multi_thread`; default `tokio::test` is fine. (Phase D's watcher tests require `multi_thread`.) +15. **`Cargo.toml` `[[test]]` ordering:** Add new `[[test]]` blocks AT THE END of the file (not interleaved). Phase A added `vault_paths_test`; Phase B appends `vault_fs_test`, `vault_frontmatter_test`, `vault_notes_io_test` in that order. + +### Constraints + +- **No scope creep:** Do not implement `preferences.rs`, `registry.rs`, `state.rs`, `watcher.rs`, or any command in Phase B. Stubs untouched. Phase C-E handle them. +- **No additional crates beyond Phase A allow-list + `nanoid`:** No `chrono`, no `time`, no `regex`. The plan uses `chrono::Utc::now()` for `current_iso()` — `chrono` was already in M2 deps via `tauri-plugin-window-state` transitive or similar; verify with `cargo tree | grep chrono`. If not present, the plan's `current_iso()` helper falls back to `std::time::SystemTime` formatting. Do not add `chrono` as a direct dep just for this — use `std::time::SystemTime` + manual ISO format. +- **`extract_properties` returns owned `BTreeMap`:** Tests call `parsed.frontmatter.extract_properties()` and inspect keys. Make it `pub fn extract_properties(&self) -> BTreeMap`. Don't return `&BTreeMap` — the test mutates the result (`contains_key`). +- **No `unwrap()` in production paths:** All `parse_note`/`serialize_note`/`read_note_from_disk`/`write_note_to_disk` paths return `AppResult`. Test code may use `unwrap()` freely. +- **Rust style:** `cargo clippy -- -D warnings` clean at each task boundary. Format with `cargo fmt`. + +### Acceptance criteria (Phase B done when all pass) + +```bash +cd /Users/h4yfans/sideproject/memry-worktrees/spike-tauri-m3 + +# Files exist +test -f apps/desktop-tauri/src-tauri/src/vault/fs.rs +test -f apps/desktop-tauri/src-tauri/src/vault/frontmatter.rs +test -f apps/desktop-tauri/src-tauri/src/vault/notes_io.rs +test -f apps/desktop-tauri/src-tauri/tests/vault_fs_test.rs +test -f apps/desktop-tauri/src-tauri/tests/vault_frontmatter_test.rs +test -f apps/desktop-tauri/src-tauri/tests/vault_notes_io_test.rs + +# Files have content (not just stubs) +[ "$(wc -l < apps/desktop-tauri/src-tauri/src/vault/fs.rs)" -gt 100 ] +[ "$(wc -l < apps/desktop-tauri/src-tauri/src/vault/frontmatter.rs)" -gt 150 ] +[ "$(wc -l < apps/desktop-tauri/src-tauri/src/vault/notes_io.rs)" -gt 50 ] + +# `nanoid` dep present +grep -q '^nanoid' apps/desktop-tauri/src-tauri/Cargo.toml + +# Tests registered +grep -q 'name = "vault_fs_test"' apps/desktop-tauri/src-tauri/Cargo.toml +grep -q 'name = "vault_frontmatter_test"' apps/desktop-tauri/src-tauri/Cargo.toml +grep -q 'name = "vault_notes_io_test"' apps/desktop-tauri/src-tauri/Cargo.toml + +# Each test file passes +cd apps/desktop-tauri/src-tauri +cargo test --features test-helpers --test vault_fs_test 2>&1 | tail -3 # 9 passed +cargo test --features test-helpers --test vault_frontmatter_test 2>&1 | tail -3 # 9 passed +cargo test --features test-helpers --test vault_notes_io_test 2>&1 | tail -3 # 5 passed + +# Full carry-over +cargo test --features test-helpers 2>&1 | tail -3 +# expect: ~60 passed (28 M2 + 9 paths + 9 fs + 9 frontmatter + 5 notes_io) + +# Rust hygiene +cd /Users/h4yfans/sideproject/memry-worktrees/spike-tauri-m3 +pnpm --filter @memry/desktop-tauri cargo:check +pnpm --filter @memry/desktop-tauri cargo:clippy + +# Commits +git log --oneline | grep -cE 'm3\(vault\)' # expect ≥ 5 (Phase A 2 + Phase B 3) + +# Electron / packages / specs / plans untouched +git diff --name-only main..HEAD -- apps/desktop/ apps/sync-server/ packages/ docs/superpowers/specs/ docs/superpowers/plans/ | wc -l +# expect 0 +``` + +### When done + +Report to user: + +``` +Phase B complete. +Tasks covered: 4, 5, 6 +Commits: 3 (..) +Rust tests: 23 new (9 fs + 9 frontmatter + 5 notes_io) + 9 paths + 28 M2 = ~60 passed +Verification: + - cargo check: clean + - cargo clippy -- -D warnings: clean + - cargo test --features test-helpers: ~60 passed, 0 failed + - Electron/packages/specs/plans untouched: 0 files + +Next: Phase C — prompts/m3/m3-phase-c-preferences-registry.md +Blockers: +``` + +If blocker: +- Frontmatter Turkish round-trip fail → check the `serde_yaml_ng::to_string` writes UTF-8 bytes (it does by default). Inspect the serialized output with `println!`. Likely culprit: missing `Value::String` wrapping for non-ASCII titles. +- Atomic-write temp leak test fail → cleanup branch missed an error path. Re-read plan Step 4.4 — the `match write_then_rename.await` block must `let _ = fs::remove_file(&temp_path).await;` before returning the error. +- `notes_io::write_skips_no_op_when_hash_matches` fail → hash comparison happened post-write instead of pre-write. The skip must short-circuit BEFORE the rename, otherwise the test hash equality is trivially true. + +If still blocked: invoke `superpowers:systematic-debugging`. Report + wait for approval. + +### Ready + +1. Invoke `superpowers:using-superpowers` and `superpowers:test-driven-development`. +2. Read plan Tasks 4, 5, 6 fully (lines ~600–1697 of the plan file). +3. Run prerequisite verification. Report results. +4. Task 4 RED-GREEN: nanoid dep → failing fs_test → impl fs.rs → 9 passed → commit `m3(vault): fs.rs atomic_write + safe_read + list + sha256 content_hash`. +5. Task 5 RED-GREEN: failing frontmatter_test → impl frontmatter.rs → 9 passed → commit `m3(vault): frontmatter.rs serde_yaml_ng parse/serialize + Turkish/multiline/date round-trip`. +6. Task 6 RED-GREEN: failing notes_io_test → impl notes_io.rs → 5 passed → commit `m3(vault): notes_io.rs read/write/delete with content-hash skip + auto-repair`. + +## PROMPT END diff --git a/prompts/m3/m3-phase-c-preferences-registry.md b/prompts/m3/m3-phase-c-preferences-registry.md new file mode 100644 index 000000000..94ced839d --- /dev/null +++ b/prompts/m3/m3-phase-c-preferences-registry.md @@ -0,0 +1,193 @@ +# M3 Phase C — Preferences + Registry (vault/preferences.rs + vault/registry.rs, TDD) + +Temiz session prompt. **Bu phase TAM TDD** — `preferences.rs` (8 test) ve `registry.rs` (6 test) RED-GREEN. + +--- + +## PROMPT START + +You are implementing **Phase C of Milestone M3** for Memry's Electron→Tauri migration. This phase lands the two persistence modules: per-vault JSON config (`/.memry/config.json`) and the multi-vault registry (`/memry-{device}/vaults.json`). Both are sync (not async) JSON IO — small files, low frequency, single-writer. + +### Context + +**Worktree:** `/Users/h4yfans/sideproject/memry-worktrees/spike-tauri-m3` +**Branch:** `m3/vault-fs-and-watcher` +**Plan:** `docs/superpowers/plans/2026-04-26-m3-vault-fs-and-watcher.md` +**Spec:** `docs/superpowers/specs/2026-04-24-electron-to-tauri-full-migration-design.md` +**Prompts README:** `prompts/m3/README.md` + +Phase A landed deps + paths. Phase B landed `fs.rs` + `frontmatter.rs` + `notes_io.rs` (23 tests). Phase C now adds `preferences.rs` + `registry.rs`. Phase C also makes `frontmatter::unix_secs_to_iso` `pub(crate)` and adds a `frontmatter_iso` helper in `mod.rs` so `registry.rs` can format ISO timestamps without re-implementing the conversion. + +### Prerequisite verification + +```bash +cd /Users/h4yfans/sideproject/memry-worktrees/spike-tauri-m3 +git rev-parse --abbrev-ref HEAD # expect: m3/vault-fs-and-watcher + +# Phase B complete +test -f apps/desktop-tauri/src-tauri/src/vault/fs.rs +test -f apps/desktop-tauri/src-tauri/src/vault/frontmatter.rs +test -f apps/desktop-tauri/src-tauri/src/vault/notes_io.rs +test -f apps/desktop-tauri/src-tauri/tests/vault_fs_test.rs +test -f apps/desktop-tauri/src-tauri/tests/vault_frontmatter_test.rs +test -f apps/desktop-tauri/src-tauri/tests/vault_notes_io_test.rs + +# Phase B tests still green +pnpm --filter @memry/desktop-tauri cargo:check +pnpm --filter @memry/desktop-tauri cargo:clippy +cd apps/desktop-tauri/src-tauri && cargo test --features test-helpers 2>&1 | tail -3 +# expect: ~60 passed (28 M2 + 9 paths + 9 fs + 9 frontmatter + 5 notes_io) + +# Phase B commits +cd /Users/h4yfans/sideproject/memry-worktrees/spike-tauri-m3 +git log --oneline | grep -cE 'm3\(vault\)' +# expect ≥ 5 + +# Stubs still in place for the modules we'll fill +test -f apps/desktop-tauri/src-tauri/src/vault/preferences.rs +test -f apps/desktop-tauri/src-tauri/src/vault/registry.rs +``` + +If any fails, STOP. Phase B must complete before Phase C starts. + +### Your scope + +Execute **Tasks 7, 8** from the plan in this order. Each is a full RED-GREEN cycle. + +- **Task 7 — `vault/preferences.rs`** (per-vault JSON config + UI prefs): + - Write 8 failing tests in `tests/vault_preferences_test.rs`: + - `init_creates_dot_memry_with_default_config`, `init_is_idempotent`, `read_config_returns_defaults_when_missing`, `write_config_round_trips`, `read_preferences_returns_defaults_when_missing`, `update_preferences_merges_partial`, `vault_name_falls_back_to_basename`, `count_markdown_files_excludes_patterns_and_hidden`. + - Register `[[test]] name = "vault_preferences_test" required-features = ["test-helpers"]`. + - Implement `preferences.rs` per plan Step 7.4: `VaultConfig` struct (excludePatterns/defaultNoteFolder/journalFolder/attachmentsFolder), `EditorPreferences` struct (width/spellCheck/autoSaveDelay/showWordCount/toolbarMode), `VaultPreferences` struct (theme/fontSize/fontFamily/accentColor/language/createInSelectedFolder/editor) — all `Default` impls + `#[serde(rename_all = "camelCase")]`. Public functions: `memry_dir`, `config_path`, `is_initialized`, `init_vault`, `read_config`, `update_config`, `read_preferences`, `update_preferences`, `vault_name`, `count_markdown_files`. Initial config blob writes the camelCase JSON shape Electron uses. Layout: `/.memry/`, `/notes/`, `/journal/`, `/attachments/{images,files}/`. + +- **Task 8 — `vault/registry.rs`** (multi-vault list at OS data dir): + - Write 6 failing tests in `tests/vault_registry_test.rs`: + - `empty_registry_when_file_missing`, `upsert_then_persist_then_reload`, `upsert_replaces_by_path_not_duplicates`, `remove_drops_vault_and_clears_current_if_match`, `touch_updates_last_opened`, `corrupt_file_falls_back_to_empty_registry`. + - Register `[[test]] name = "vault_registry_test" required-features = ["test-helpers"]`. + - Implement `registry.rs` per plan Step 8.4: `VaultInfo` struct (path/name/noteCount/taskCount/lastOpened/isDefault), `VaultRegistry` struct (`vaults: Vec`, `current: Option`), methods: `load(path) -> AppResult` (returns default on missing/corrupt), `save(path)`, `find`, `upsert`, `remove`, `set_current`, `touch`. Free function `registry_path()` returns `/memry-{device}/vaults.json` reading `MEMRY_DEVICE` env (matches M2 DB path scheme). + - Step 8.5: make `frontmatter::unix_secs_to_iso` `pub(crate)` and add `frontmatter_iso` re-export in `vault/mod.rs` so `registry.rs::current_iso()` can call `crate::vault::frontmatter_iso(secs)`. + +### Methodology — TDD mandatory for both tasks + +1. **Invoke `superpowers:using-superpowers` and `superpowers:test-driven-development`** first. +2. **Two full RED-GREEN cycles. One commit per task.** +3. For Task 7: + - Step 7.1: copy plan's test verbatim (lines ~1706–1810). 8 tests. + - Step 7.2: register `[[test]]` block. + - Step 7.3: RED → unresolved `init_vault`, `read_config`, `update_config`, `read_preferences`, `update_preferences`, `vault_name`, `count_markdown_files`. + - Step 7.4: implement per plan (lines ~1830–2150). + - Step 7.5: GREEN → 8 passed. + - Step 7.6: commit `m3(vault): preferences.rs vault config + UI prefs + count_markdown_files`. +4. For Task 8: + - Step 8.1: copy plan's test verbatim (lines ~2160–2255). 6 tests. + - Step 8.2: register `[[test]]` block. + - Step 8.3: RED → unresolved imports. + - Step 8.4: implement per plan (lines ~2275–2377). + - Step 8.5: make `frontmatter::unix_secs_to_iso` `pub(crate)` + add `frontmatter_iso` helper in `mod.rs`. `cargo check` to confirm cross-module path works. + - Step 8.6: GREEN → 6 passed. + - Step 8.7: commit `m3(vault): registry.rs multi-vault list at /memry-{device}/vaults.json`. + +### Critical gotchas + +1. **Sync IO, not async:** Both modules use `std::fs::*`, NOT `tokio::fs::*`. The files are tiny and writes are user-driven (open/switch/save), not high-frequency. Plan Step 7.4 + 8.4 use `std::fs` deliberately — don't "modernize" to tokio. +2. **`init_vault` is idempotent:** `fs::create_dir_all` is idempotent on existing dirs. The config write uses `if !cfg_path.exists()` to avoid clobbering user edits. Test `init_is_idempotent` calls `init_vault` twice and expects no error. The `VAULT_FOLDERS` const lists `notes`, `journal`, `attachments`, `attachments/images`, `attachments/files` — all five must exist after init. +3. **`read_config` returns defaults on missing OR corrupt:** Plan Step 7.4's `read_config_blob` returns the default JSON if the file doesn't exist. The test `corrupt_file_falls_back_to_empty_registry` verifies this for the registry; the same defensive pattern applies to config (`unwrap_or_default()` after `from_str`). NEVER error on a fresh vault — that would brick onboarding. +4. **`update_preferences_merges_partial`:** The function takes a `serde_json::Map` (NOT a typed struct) and merges into the existing `preferences` object. Test passes `{"theme": "dark"}` and asserts `theme == "dark"` AND `fontSize == "medium"` (default unchanged). The merge happens at the JSON `Value::Object` level, not the typed `VaultPreferences` level — round-trip through `serde_json::to_value` and back, then merge keys, then deserialize. +5. **`count_markdown_files` excludes hidden + excludePatterns:** It walks the vault tree, counts only `*.md` and `*.markdown` files, skips dotfiles + dirs in the `excludePatterns` list. The function is sync — Phase E's `vault_open` command calls it during the open flow. Use `walkdir = "2"` if needed; check `cargo tree` first — if not present, write a manual recursive walker (10 lines). +6. **`registry.rs` path scheme matches M2:** `MEMRY_DEVICE` env var defaults to `"default"`. Path: `/memry-{device}/vaults.json`. M2's DB lives at `/memry-{device}/data.db` — same parent directory. `registry_path()` MUST produce a sibling of M2's `data.db`. +7. **`registry::touch` requires unique `last_opened`:** Test `touch_updates_last_opened` sleeps 10ms then calls `touch`. The `last_opened` ISO string must change. If your `current_iso()` truncates to seconds, the 10ms sleep won't move the second-counter. Plan's `unix_secs_to_iso` formats with sub-second precision OR the helper falls back to nanos. Verify by reading the `frontmatter::unix_secs_to_iso` you wrote in Phase B — if seconds-only, bump `current_iso()` in `registry.rs` to use `as_millis()` or `as_nanos()` and format accordingly. (Plan's exact `current_iso` impl in `registry.rs` uses `as_secs()` then calls `frontmatter_iso` — the `unix_secs_to_iso` from Phase B may already include ms. If the test flakes, revisit Phase B impl.) +8. **`frontmatter::unix_secs_to_iso` visibility:** Phase B made this private. Phase C Step 8.5 elevates it to `pub(crate)`. Without this, `registry.rs::current_iso` won't compile. The `frontmatter_iso` re-export in `mod.rs` is a stable name for the rest of the crate (so `registry.rs` doesn't need to know `frontmatter` is the source). +9. **`VaultInfo` field order:** Match plan Step 8.4 exactly: `path`, `name`, `note_count: i64`, `task_count: i64`, `last_opened: String`, `is_default: bool`. Specta-generated TS preserves field order; Phase G's `bindings:check` will diff against renderer expectations. +10. **`VaultRegistry::load` is fault-tolerant:** Returns `Self::default()` (empty) on missing OR malformed JSON. The `unwrap_or_default()` after `serde_json::from_str` handles the corrupt case. Test `corrupt_file_falls_back_to_empty_registry` writes `"{not valid json}"` and expects `Ok(empty)` — never propagate the parse error. +11. **`registry::save` creates parent dir:** First call after a fresh device install: `/memry-{device}/` doesn't exist yet. `save` MUST `fs::create_dir_all(parent)` before writing. Plan Step 8.4 handles this; do not skip. +12. **`Cargo.toml` `[[test]]` ordering:** Append after Phase B's blocks. Order matters for predictable parallel test runs but is mostly cosmetic. + +### Constraints + +- **No scope creep:** Do not implement `state.rs`, `watcher.rs`, or any command in Phase C. Stubs untouched. Phase D handles state + watcher. +- **No new crates:** `walkdir` is the only candidate addition (for `count_markdown_files`). If you can avoid it with a manual `read_dir` recursion, do so. The plan's exact impl uses manual recursion to keep deps tight. +- **No Phase D wiring:** Do not touch `app_state.rs` or `lib.rs::run` to wire `VaultRuntime` — that is Phase D's job. The `mod.rs` re-exports are still commented at end of Phase C; Phase D enables them. +- **No `unwrap()` in production paths:** All `init_vault`, `read_config`, `update_config`, `update_preferences`, `VaultRegistry::load`, `VaultRegistry::save`, `registry_path` return `AppResult`. Test code may use `unwrap()` freely. +- **Rust style:** `cargo clippy -- -D warnings` clean at each task boundary. Format with `cargo fmt`. + +### Acceptance criteria (Phase C done when all pass) + +```bash +cd /Users/h4yfans/sideproject/memry-worktrees/spike-tauri-m3 + +# Files implemented +test -f apps/desktop-tauri/src-tauri/src/vault/preferences.rs +test -f apps/desktop-tauri/src-tauri/src/vault/registry.rs +[ "$(wc -l < apps/desktop-tauri/src-tauri/src/vault/preferences.rs)" -gt 100 ] +[ "$(wc -l < apps/desktop-tauri/src-tauri/src/vault/registry.rs)" -gt 80 ] + +# `frontmatter::unix_secs_to_iso` elevated to pub(crate) +grep -q 'pub(crate) fn unix_secs_to_iso' apps/desktop-tauri/src-tauri/src/vault/frontmatter.rs + +# `frontmatter_iso` helper in mod.rs +grep -q 'frontmatter_iso' apps/desktop-tauri/src-tauri/src/vault/mod.rs + +# Tests registered +grep -q 'name = "vault_preferences_test"' apps/desktop-tauri/src-tauri/Cargo.toml +grep -q 'name = "vault_registry_test"' apps/desktop-tauri/src-tauri/Cargo.toml + +# Each test file passes +cd apps/desktop-tauri/src-tauri +cargo test --features test-helpers --test vault_preferences_test 2>&1 | tail -3 # 8 passed +cargo test --features test-helpers --test vault_registry_test 2>&1 | tail -3 # 6 passed + +# Full carry-over +cargo test --features test-helpers 2>&1 | tail -3 +# expect: ~74 passed (28 M2 + 9 paths + 9 fs + 9 frontmatter + 5 notes_io + 8 prefs + 6 registry) + +# Rust hygiene +cd /Users/h4yfans/sideproject/memry-worktrees/spike-tauri-m3 +pnpm --filter @memry/desktop-tauri cargo:check +pnpm --filter @memry/desktop-tauri cargo:clippy + +# Commits +git log --oneline | grep -cE 'm3\(vault\)' # expect ≥ 7 + +# Electron / packages / specs / plans untouched +git diff --name-only main..HEAD -- apps/desktop/ apps/sync-server/ packages/ docs/superpowers/specs/ docs/superpowers/plans/ | wc -l +# expect 0 +``` + +### When done + +Report to user: + +``` +Phase C complete. +Tasks covered: 7, 8 +Commits: 2 (..) +Rust tests: 14 new (8 prefs + 6 registry) + 32 prior = ~74 passed +Verification: + - cargo check: clean + - cargo clippy -- -D warnings: clean + - cargo test --features test-helpers: ~74 passed, 0 failed + - frontmatter::unix_secs_to_iso elevated to pub(crate) + - mod.rs frontmatter_iso re-export added + - Electron/packages/specs/plans untouched: 0 files + +Next: Phase D — prompts/m3/m3-phase-d-watcher-runtime-state.md +Blockers: +``` + +If blocker: +- `update_preferences_merges_partial` fails → check the merge happens at `Value::Object` level (`Map`) not at `VaultPreferences` typed level. Pure JSON merge then deserialize. +- `touch_updates_last_opened` fails (`assert_ne!(before, after)`) → `current_iso()` returns same value across 10ms sleep. Bump precision to ms in `frontmatter::unix_secs_to_iso` or use `as_nanos()` in `registry::current_iso` directly. +- `corrupt_file_falls_back_to_empty_registry` fails → `unwrap_or_default()` after `serde_json::from_str` was replaced with `?`. Restore the swallow pattern; corrupt files MUST not panic the registry. +- `count_markdown_files` over-counts → didn't apply `excludePatterns` to dirs OR didn't skip dotfiles. Test the walker independently with `dbg!`. + +If still blocked: invoke `superpowers:systematic-debugging`. Report + wait for approval. + +### Ready + +1. Invoke `superpowers:using-superpowers` and `superpowers:test-driven-development`. +2. Read plan Tasks 7, 8 fully (lines ~1697–2422 of the plan file). +3. Run prerequisite verification. Report results. +4. Task 7 RED-GREEN: failing prefs_test → impl preferences.rs → 8 passed → commit `m3(vault): preferences.rs vault config + UI prefs + count_markdown_files`. +5. Task 8 RED-GREEN: failing registry_test → impl registry.rs + elevate `unix_secs_to_iso` + add `frontmatter_iso` helper → 6 passed → commit `m3(vault): registry.rs multi-vault list at /memry-{device}/vaults.json`. + +## PROMPT END diff --git a/prompts/m3/m3-phase-d-watcher-runtime-state.md b/prompts/m3/m3-phase-d-watcher-runtime-state.md new file mode 100644 index 000000000..fd1b52b91 --- /dev/null +++ b/prompts/m3/m3-phase-d-watcher-runtime-state.md @@ -0,0 +1,220 @@ +# M3 Phase D — Watcher + Runtime State (vault/watcher.rs + vault/state.rs + AppState wiring) + +Temiz session prompt. **Bu phase TDD** for watcher (4 multi_thread test). State wiring verification-driven. + +**Order matters:** Task 10 (watcher) first, then Task 9 (state). State imports `WatcherHandle` from watcher — without watcher implemented first, state won't compile. + +--- + +## PROMPT START + +You are implementing **Phase D of Milestone M3** for Memry's Electron→Tauri migration. This phase lands the live runtime: the `notify`-based file watcher with 150ms path-keyed debounce, and `VaultRuntime` — the thread-safe state owner that holds the current vault, registry handle, indexing status, and active watcher handle. It then wires `VaultRuntime` into `AppState` so commands (Phase E) can access it via `State<'_, AppState>`. + +### Context + +**Worktree:** `/Users/h4yfans/sideproject/memry-worktrees/spike-tauri-m3` +**Branch:** `m3/vault-fs-and-watcher` +**Plan:** `docs/superpowers/plans/2026-04-26-m3-vault-fs-and-watcher.md` +**Spec:** `docs/superpowers/specs/2026-04-24-electron-to-tauri-full-migration-design.md` +**Prompts README:** `prompts/m3/README.md` + +Phase A-C landed deps + paths + fs/frontmatter/notes_io + preferences/registry (37 vault tests). Phase D unifies them under a runtime state object and adds the live watcher loop. + +### Prerequisite verification + +```bash +cd /Users/h4yfans/sideproject/memry-worktrees/spike-tauri-m3 +git rev-parse --abbrev-ref HEAD # expect: m3/vault-fs-and-watcher + +# Phase C complete +test -f apps/desktop-tauri/src-tauri/src/vault/preferences.rs +test -f apps/desktop-tauri/src-tauri/src/vault/registry.rs +[ "$(wc -l < apps/desktop-tauri/src-tauri/src/vault/preferences.rs)" -gt 100 ] +[ "$(wc -l < apps/desktop-tauri/src-tauri/src/vault/registry.rs)" -gt 80 ] +grep -q 'pub(crate) fn unix_secs_to_iso' apps/desktop-tauri/src-tauri/src/vault/frontmatter.rs +grep -q 'frontmatter_iso' apps/desktop-tauri/src-tauri/src/vault/mod.rs + +# Stubs still in place for state + watcher +test -f apps/desktop-tauri/src-tauri/src/vault/state.rs # stub +test -f apps/desktop-tauri/src-tauri/src/vault/watcher.rs # stub + +# All Phase A-C tests still green +pnpm --filter @memry/desktop-tauri cargo:check +pnpm --filter @memry/desktop-tauri cargo:clippy +cd apps/desktop-tauri/src-tauri && cargo test --features test-helpers 2>&1 | tail -3 +# expect: ~74 passed (28 M2 + 9 paths + 9 fs + 9 frontmatter + 5 notes_io + 8 prefs + 6 registry) + +cd /Users/h4yfans/sideproject/memry-worktrees/spike-tauri-m3 +git log --oneline | grep -cE 'm3\(vault\)' # expect ≥ 7 +``` + +If any fails, STOP. Phase C must complete before Phase D starts. + +### Your scope + +Execute **Tasks 10, 9** from the plan in this order. **Watcher first, state second.** + +- **Task 10 — `vault/watcher.rs`** (notify v6 + 150ms debounce + `vault-changed` events): + - Write 4 failing tests in `tests/vault_watcher_test.rs`: + - `detects_new_file_within_debounce_window`, `debounces_rapid_writes_to_same_file`, `ignores_dot_memry_writes`, `detects_deletion`. All `#[tokio::test(flavor = "multi_thread")]`. + - Register `[[test]] name = "vault_watcher_test" required-features = ["test-helpers"]`. + - Implement `watcher.rs` per plan Step 10.3: + - `VaultEvent { relative_path: String, kind: VaultEventKind }` (Specta Type, camelCase serialize). + - `VaultEventKind { Created, Modified, Deleted }` (Specta Type, lowercase serialize). + - `WatcherHandle` struct with `_watcher: RecommendedWatcher`, `_scheduler: JoinHandle<()>`, `cancel: Arc`. `Drop` impl sets `cancel = true`. + - `start(vault_root, out: UnboundedSender) -> AppResult`: notify recursive watcher, drain task that fills a path-keyed `PendingMap`, scheduler task that emits ready entries every 50ms. + - `should_ignore(root, path)` filters `.foo` segments anywhere AND unsupported extensions. + - `classify(kind: &EventKind)` maps notify kinds to `VaultEventKind`. + - 150ms debounce constant `DEBOUNCE_MS`. + +- **Task 9 — `vault/state.rs` + `AppState` wiring + `lib.rs::run` boot**: + - Implement `state.rs` per plan Step 9.1: + - `VaultStatus { is_open, path: Option, is_indexing, index_progress: u8, error: Option }` (Specta Type, camelCase, `Default`). + - `VaultRuntime { inner: Mutex, watcher_slot: Mutex>, registry_path: PathBuf }`. + - `RuntimeInner { current: Option, is_indexing, index_progress, error, registry: VaultRegistry }`. + - Methods: `boot()`, `status()`, `current_path()`, `registry_snapshot()`, `set_current()`, `upsert_registry()`, `remove_from_registry()`, `touch_registry()`, `set_indexing()`, `set_error()`, `require_current()`. All locks use `unwrap_or_else(|p| p.into_inner())` poison handling. + - Step 9.2: re-enable `pub use frontmatter::{NoteFrontmatter, ParsedNote}; pub use notes_io::{NoteOnDisk, ReadNoteResult}; pub use preferences::{VaultConfig, VaultPreferences}; pub use registry::{VaultInfo, VaultRegistry}; pub use state::{VaultRuntime, VaultStatus};` in `vault/mod.rs`. (Phase A commented these out; Phase D enables them now that the symbols exist.) + - Step 9.3: extend `AppState` to `{ db: Db, vault: Arc }` in `app_state.rs`. Add `AppState::new(db, vault)` constructor. + - Step 9.4: wire `VaultRuntime::boot()` into `lib.rs::run`'s `init_app_state` function. Boot order: `resolve_db_path` → `Db::open` → `VaultRuntime::boot()` → `AppState::new(db, vault)`. + +### Methodology — TDD for watcher, verification for state + +1. **Invoke `superpowers:using-superpowers` and `superpowers:test-driven-development`** first. +2. **Task 10 (watcher) — full RED-GREEN:** + - Step 10.1: write the 4-test file verbatim from plan lines ~2655–2759. Tests use `#[tokio::test(flavor = "multi_thread")]` and `tokio::sync::mpsc::unbounded_channel`. + - Step 10.2: register `[[test]]` block. + - Run RED → unresolved `watcher::start`, `VaultEvent`, `VaultEventKind`. Confirm. + - Step 10.3: implement `watcher.rs` per plan lines ~2773–2994. The implementation has THREE async tasks: notify callback (sync, on a notify thread, bridges to Tokio), drain task (consumes raw events into pending map), scheduler task (50ms tick, emits debounced events). + - Step 10.4: `cargo check` first — watcher imports are tricky; confirm before running tests. + - Step 10.5: run watcher tests. Allow 10–15s; FSEvents has ~50ms latency, debounce adds 150ms, scheduler ticks 50ms — total per test budget ~2s. + - Step 10.6: commit `m3(vault): watcher.rs notify+debounce emitting VaultEvent {path, kind}`. + +3. **Task 9 (state + wiring) — verification-driven:** + - Step 9.1: implement `state.rs` per plan lines ~2436–2572. **Note:** state.rs imports `crate::vault::watcher::WatcherHandle` which now exists from Task 10. + - Step 9.2: re-enable `pub use` block in `mod.rs`. `cargo check` should pass — every re-exported symbol now exists. + - Step 9.3: rewrite `app_state.rs` per plan Step 9.3 (replace contents). The struct now has TWO fields: `db: Db` (M2) + `vault: Arc` (M3). Old M2 sites that say `AppState { db }` won't compile — use the constructor. + - Step 9.4: edit `lib.rs::init_app_state` per plan Step 9.4. Three lines: open db, boot vault runtime, build AppState. Make sure the function signature still returns `AppResult`. + - Step 9.5: `cargo check && cargo test --features test-helpers --tests` — every prior test must stay green. `state.rs` has no integration test of its own (state is exercised by Task 11's command tests + the runtime smoke). + - Step 9.6: commit `m3(vault): VaultRuntime + AppState extension + boot wiring`. + +### Critical gotchas + +1. **Watcher test timing:** `#[tokio::test(flavor = "multi_thread")]` is mandatory. Default single-threaded flavor will deadlock the drain+scheduler+notify-thread arrangement. Plan's tests use multi_thread; do NOT downgrade. +2. **100ms warm-up sleep before writing:** Each watcher test has `tokio::time::sleep(Duration::from_millis(100)).await` after `start()` and before the first `fs::write`. This lets notify install the FSEvents subscription. Skip it and notify misses the first event. Test `detects_new_file_within_debounce_window` will flake without warm-up. +3. **`should_ignore` checks dotfiles AT EVERY component:** `notes/.git/HEAD` must be ignored even if `notes/` is fine. The plan's `should_ignore` walks `path.strip_prefix(root)?.components()` and returns true if ANY normal segment starts with `.`. Reproduce exactly. +4. **`should_ignore` for unsupported extensions only applies to files:** Directories (e.g. mid-walk `notes/foo/`) must NOT be filtered out by extension check (they have no extension). Plan's impl gates the extension check behind `if !path.is_dir()`. Don't lose this branch. +5. **`classify(EventKind)` rename → Modified:** macOS FSEvents emits rename as `EventKind::Modify(ModifyKind::Name(...))`. Plan classifies all `Modify` as `Modified`. The spec accepts this as the "safe upper bound" for rename detection (real rename detection is M5). +6. **`debounces_rapid_writes_to_same_file` upper bound:** Plan says `count <= 3`. macOS FSEvents under load can coalesce 5 writes into multiple events; if the test flakes, plan Step 10.5 says bump the upper bound to 5 and document in a code comment. **Default to 3 first** — the debounce should make 5 writes → 1–2 emitted events. Bump only if you see flakes after 3 runs. +7. **`detects_deletion` poll loop:** Test polls `rx.recv()` for up to 2 seconds looking for a `VaultEventKind::Deleted` event. macOS FSEvents may emit `Modified` first (file shrinks) then `Deleted`. The poll loop continues past `Modified` events. Don't change to `expect_one_event` semantics — the loop is correct. +8. **`ignores_dot_memry_writes` requires `.memry/` to be inside the canonicalized root:** The test `fs::create_dir_all(vault.path().join(".memry"))` creates the dir inside the temp vault, then writes a file. `should_ignore` strips the canonical root prefix and sees `.memry/data.db`; the dotfile check on the first segment fires → ignored. `timeout(Duration::from_millis(500), rx.recv()).await.is_err()` confirms no event was emitted. +9. **`WatcherHandle` Drop semantics:** Setting `cancel = true` makes the scheduler/drain tasks exit on their next tick (50ms). The notify watcher is dropped, which unsubscribes from FSEvents synchronously. Tests `drop(handle)` at the end to release file handles before the temp dir cleanup. +10. **`state.rs::watcher_slot` is a separate Mutex from `inner`:** Plan deliberately splits them. Reasons: (a) `watcher_slot.take()` runs during vault close — should not block on `inner` lock; (b) the watcher's drop drains the channel, which we don't want under the inner lock. Don't merge into one mutex. +11. **`VaultRuntime::boot()` is fault-tolerant on missing registry:** `VaultRegistry::load(®istry_path).unwrap_or_default()` (Phase C contract). Boot must succeed on a brand-new device install with no `vaults.json`. Plan Step 9.1 uses `unwrap_or_default` exactly here. +12. **`AppState::new` constructor required:** Phase G's command code uses `AppState::new(db, vault)` from the boot path. Don't make `AppState` public-ctor-only via field literal initialization — Specta-generated test fixtures and any future re-init path benefit from the named constructor. +13. **Re-exports in `mod.rs` must compile:** After Step 9.2, `pub use state::{VaultRuntime, VaultStatus}` etc. Every name in the re-export block must be a public item in its module. If you accidentally renamed `VaultStatus` → `VaultRuntimeStatus` in state.rs, the re-export breaks. Plan's exact names: `VaultRuntime`, `VaultStatus` from `state`; `VaultInfo`, `VaultRegistry` from `registry`; `VaultConfig`, `VaultPreferences` from `preferences`; `NoteOnDisk`, `ReadNoteResult` from `notes_io`; `NoteFrontmatter`, `ParsedNote` from `frontmatter`. +14. **`init_app_state` Arc-wrap the runtime:** `Arc::new(VaultRuntime::boot()?)`. Without `Arc`, Tauri's `State<'_, AppState>` would attempt to clone `VaultRuntime`, which holds `Mutex` + `JoinHandle` — not clonable. The Arc is the share boundary. + +### Constraints + +- **No scope creep:** Do not implement vault commands, shell/dialog commands, the URI protocol handler, or the drag-drop spike in Phase D. Phase E and Phase F handle them. +- **No `tokio::sync::Mutex` for state:** Plan deliberately uses `std::sync::Mutex` because Tauri commands hold the lock briefly per call and don't need async-aware locking. Tokio Mutex is allowed inside `watcher.rs`'s scheduler/drain tasks, but `state.rs` stays sync-Mutex. +- **No `parking_lot::Mutex`:** Plan's comment mentions it as an alternative but uses `std::sync::Mutex`. Don't add `parking_lot` as a new dep. +- **No new tests for `state.rs`:** State is exercised by Task 11's command tests + Phase G's runtime smoke. Don't write a `vault_state_test.rs` — that adds budget without coverage value (the unit tests would just exercise `Mutex` plumbing). +- **No watcher fanout to Tauri events yet:** Phase D only writes the watcher to a Tokio `UnboundedSender`. Bridging to Tauri's `app.emit("vault-changed", ...)` happens in Phase E's `vault_open` command — which spawns the consumer task that reads from the channel and forwards to the renderer. +- **Rust style:** `cargo clippy -- -D warnings` clean at each task boundary. Format with `cargo fmt`. + +### Acceptance criteria (Phase D done when all pass) + +```bash +cd /Users/h4yfans/sideproject/memry-worktrees/spike-tauri-m3 + +# Files implemented +test -f apps/desktop-tauri/src-tauri/src/vault/watcher.rs +test -f apps/desktop-tauri/src-tauri/src/vault/state.rs +test -f apps/desktop-tauri/src-tauri/tests/vault_watcher_test.rs +[ "$(wc -l < apps/desktop-tauri/src-tauri/src/vault/watcher.rs)" -gt 150 ] +[ "$(wc -l < apps/desktop-tauri/src-tauri/src/vault/state.rs)" -gt 100 ] + +# Re-exports enabled +grep -q '^pub use state::{VaultRuntime, VaultStatus}' apps/desktop-tauri/src-tauri/src/vault/mod.rs +grep -q '^pub use registry::{VaultInfo, VaultRegistry}' apps/desktop-tauri/src-tauri/src/vault/mod.rs +grep -q '^pub use frontmatter::{NoteFrontmatter, ParsedNote}' apps/desktop-tauri/src-tauri/src/vault/mod.rs +grep -q '^pub use notes_io::{NoteOnDisk, ReadNoteResult}' apps/desktop-tauri/src-tauri/src/vault/mod.rs +grep -q '^pub use preferences::{VaultConfig, VaultPreferences}' apps/desktop-tauri/src-tauri/src/vault/mod.rs + +# AppState extended +grep -q 'pub vault: Arc' apps/desktop-tauri/src-tauri/src/app_state.rs +grep -q 'pub fn new(db: Db, vault: Arc)' apps/desktop-tauri/src-tauri/src/app_state.rs + +# lib.rs boot wiring +grep -q 'VaultRuntime::boot' apps/desktop-tauri/src-tauri/src/lib.rs + +# Test registered +grep -q 'name = "vault_watcher_test"' apps/desktop-tauri/src-tauri/Cargo.toml + +# Watcher test passes +cd apps/desktop-tauri/src-tauri +cargo test --features test-helpers --test vault_watcher_test 2>&1 | tail -3 # 4 passed + +# Full carry-over green +cargo test --features test-helpers 2>&1 | tail -3 +# expect: ~78 passed (74 prior + 4 watcher) + +# Rust hygiene +cd /Users/h4yfans/sideproject/memry-worktrees/spike-tauri-m3 +pnpm --filter @memry/desktop-tauri cargo:check +pnpm --filter @memry/desktop-tauri cargo:clippy + +# Commits +git log --oneline | grep -cE 'm3\(vault\)' # expect ≥ 9 (Phase A-C 7 + Phase D 2) + +# Electron / packages / specs / plans untouched +git diff --name-only main..HEAD -- apps/desktop/ apps/sync-server/ packages/ docs/superpowers/specs/ docs/superpowers/plans/ | wc -l +# expect 0 +``` + +### When done + +Report to user: + +``` +Phase D complete. +Tasks covered: 10, 9 (in this execution order; plan listed as 9, 10) +Commits: 2 (..) +Rust tests: 4 new (watcher) + 74 prior = ~78 passed +Verification: + - cargo check: clean + - cargo clippy -- -D warnings: clean + - cargo test --features test-helpers: ~78 passed, 0 failed + - mod.rs re-exports enabled (5 pub use lines) + - AppState extended with vault: Arc + - lib.rs::init_app_state wires VaultRuntime::boot() + - Electron/packages/specs/plans untouched: 0 files + +Next: Phase E — prompts/m3/m3-phase-e-tauri-commands.md +Blockers: +``` + +If blocker: +- Watcher test flake on `debounces_rapid_writes_to_same_file` → run 3× to confirm. If consistent, bump upper bound to 5 + add code comment explaining macOS FSEvents coalescing. +- `state.rs` imports `crate::vault::watcher::WatcherHandle` but watcher.rs hasn't exported it → check Step 10.3 — `WatcherHandle` must be `pub struct`. Re-read plan line ~2814. +- `app_state.rs` change breaks M2 settings tests → the M2 settings code uses `state.db.with_conn(|c| ...)`. The new `AppState { db, vault }` keeps `db` as a public field; settings code still compiles. If a settings test fails with "expected AppState ...", you removed `pub` accidentally. +- `init_app_state` panics at boot → `VaultRuntime::boot()` calls `registry::registry_path()` which requires `directories::ProjectDirs::from(...)` to resolve. On dev machines this is fine; on CI sandboxes it might fail. Check the error path returns `AppResult` not panic. + +If still blocked: invoke `superpowers:systematic-debugging`. Report + wait for approval. + +### Ready + +1. Invoke `superpowers:using-superpowers` and `superpowers:test-driven-development`. +2. Read plan Tasks 9 and 10 fully (lines ~2424–3022 of the plan file). **Read Task 10 first** — Task 9 imports from it. +3. Run prerequisite verification. Report results. +4. Task 10 RED-GREEN: failing watcher_test → impl watcher.rs (notify + 3 async tasks + should_ignore + classify) → 4 passed → commit `m3(vault): watcher.rs notify+debounce emitting VaultEvent {path, kind}`. +5. Task 9 verification: + - Implement state.rs (VaultStatus + VaultRuntime + 11 methods). + - Re-enable mod.rs `pub use` block (5 re-exports). + - Extend app_state.rs (`vault: Arc` field + `new()` constructor). + - Wire `init_app_state` in lib.rs. + - `cargo check && cargo test --features test-helpers --tests` → all prior + new compile, all tests stay green. + - Commit `m3(vault): VaultRuntime + AppState extension + boot wiring`. + +## PROMPT END diff --git a/prompts/m3/m3-phase-e-tauri-commands.md b/prompts/m3/m3-phase-e-tauri-commands.md new file mode 100644 index 000000000..b1b83e3fa --- /dev/null +++ b/prompts/m3/m3-phase-e-tauri-commands.md @@ -0,0 +1,245 @@ +# M3 Phase E — Tauri Commands (vault.rs + shell.rs + dialog.rs + capabilities) + +Temiz session prompt. Bu phase verification-driven (TDD değil — komutlar ince wrapper, test'ler Phase G'deki runtime e2e ve manuel smoke ile karşılanır). + +--- + +## PROMPT START + +You are implementing **Phase E of Milestone M3** for Memry's Electron→Tauri migration. This phase lands the full command surface that the renderer will call: 13 `vault_*` commands (open / close / status / current / get_all / switch / remove / get_config / update_config / list_notes / read_note / write_note / delete_note / reveal / reindex), 3 `shell_*` commands (open_url / open_path / reveal_in_finder), and 2 `dialog_*` commands (choose_folder / choose_files). Capabilities and the `tauri-plugin-dialog` registration round it out. + +### Context + +**Worktree:** `/Users/h4yfans/sideproject/memry-worktrees/spike-tauri-m3` +**Branch:** `m3/vault-fs-and-watcher` +**Plan:** `docs/superpowers/plans/2026-04-26-m3-vault-fs-and-watcher.md` +**Spec:** `docs/superpowers/specs/2026-04-24-electron-to-tauri-full-migration-design.md` +**Prompts README:** `prompts/m3/README.md` + +Phase A-D landed deps + paths + fs/frontmatter/notes_io + preferences/registry + watcher + state/AppState/lib boot wiring (78 vault tests). Phase E exposes that runtime through Tauri commands. The commands themselves are thin async wrappers — the heavy lifting lives in `vault::*` modules. Phase E's correctness is exercised by Phase G's runtime e2e + manual smoke (no separate Rust integration tests in this phase). + +### Prerequisite verification + +```bash +cd /Users/h4yfans/sideproject/memry-worktrees/spike-tauri-m3 +git rev-parse --abbrev-ref HEAD # expect: m3/vault-fs-and-watcher + +# Phase D complete +test -f apps/desktop-tauri/src-tauri/src/vault/state.rs +test -f apps/desktop-tauri/src-tauri/src/vault/watcher.rs +[ "$(wc -l < apps/desktop-tauri/src-tauri/src/vault/state.rs)" -gt 100 ] +[ "$(wc -l < apps/desktop-tauri/src-tauri/src/vault/watcher.rs)" -gt 150 ] +grep -q 'pub vault: Arc' apps/desktop-tauri/src-tauri/src/app_state.rs +grep -q 'VaultRuntime::boot' apps/desktop-tauri/src-tauri/src/lib.rs +grep -q '^pub use state::{VaultRuntime, VaultStatus}' apps/desktop-tauri/src-tauri/src/vault/mod.rs + +# All Phase A-D tests still green +pnpm --filter @memry/desktop-tauri cargo:check +pnpm --filter @memry/desktop-tauri cargo:clippy +cd apps/desktop-tauri/src-tauri && cargo test --features test-helpers 2>&1 | tail -3 +# expect: ~78 passed (74 prior + 4 watcher) + +cd /Users/h4yfans/sideproject/memry-worktrees/spike-tauri-m3 +git log --oneline | grep -cE 'm3\(vault\)' # expect ≥ 9 + +# Phase D's stubs (commands/shell.rs and commands/dialog.rs) — likely don't exist yet OR are M2 settings-only; check what's there +ls apps/desktop-tauri/src-tauri/src/commands/ +# expect: mod.rs, settings.rs (from M2). Phase E will add vault.rs, shell.rs, dialog.rs + +# Watcher_slot wiring spot-check — Task 11 vault_open uses it +grep -q 'watcher_slot' apps/desktop-tauri/src-tauri/src/vault/state.rs +``` + +If any fails, STOP. Phase D must complete before Phase E starts. + +### Your scope + +Execute **Tasks 11, 12** from the plan in this order. + +- **Task 11 — `commands/vault.rs`** (13 vault commands + lib.rs wiring): + - Create `commands/vault.rs` per plan Step 11.1 with the following Tauri commands. Each is `#[tauri::command]` + `#[specta::specta]` and returns `AppResult<...>`: + - `vault_open(state, app, input: VaultOpenInput { path }) -> VaultOpenOutput { success, vault, error }` — opens a vault: validate dir, init `.memry/`, set indexing, stop prior watcher, set current, count notes, upsert + touch registry, start watcher, spawn `vault-changed` event forwarder, emit `vault-status-changed`. + - `vault_close(state, app)` — drop watcher slot, set current `None`, set indexing false, emit status. + - `vault_get_status(state) -> VaultStatus`. + - `vault_get_current(state) -> VaultCurrent { path: Option }`. + - `vault_get_all(state) -> VaultGetAllOutput { vaults, currentVault }`. + - `vault_switch(state, app, input: VaultPathInput)` — alias to `vault_open`. + - `vault_remove(state, app, input: VaultPathInput)` — close-if-current, then `remove_from_registry`. + - `vault_get_config(state) -> VaultConfig`. + - `vault_update_config(state, input: VaultUpdateConfigInput)` — partial merge + `update_config`. + - `vault_list_notes(state) -> VaultListNotesOutput { paths }` — `list_supported_files`, filter to `.md`/`.markdown` only. + - `vault_read_note(state, input: VaultReadNoteInput { relativePath }) -> Option`. + - `vault_write_note(state, input: VaultWriteNoteInput { relativePath, frontmatter, content }) -> NoteOnDisk`. + - `vault_delete_note(state, input: VaultReadNoteInput)`. + - `vault_reveal(state)` — calls `commands::shell::reveal_in_finder_inner(¤t_path)`. + - `vault_reindex(_state) -> VaultReindexOutput { success: true, files_indexed: 0, duration: 0, deferred_until: "M7" }`. + - Update `commands/mod.rs` to declare `pub mod settings; pub mod vault; pub mod shell; pub mod dialog;`. + - Register every command in `lib.rs::run`'s `.invoke_handler(tauri::generate_handler![...])` block (per plan Step 11.3). + - Add minimal stubs to `commands/shell.rs` and `commands/dialog.rs` (signatures only, no real impl) so the macros find symbols and `cargo check` passes. Plan Step 11.4 supplies the exact stubs. + +- **Task 12 — `commands/shell.rs` + `commands/dialog.rs` + capabilities**: + - Replace `commands/shell.rs` stubs with real impl per plan Step 12.1: + - `shell_open_url(app, url)` — reject non-http(s) schemes via `AppError::Validation`, then `app.shell().open(url, None)`. + - `shell_open_path(app, path)` — reject non-absolute paths via `AppError::Validation`, reject non-existent via `AppError::NotFound`, then `app.shell().open(path, None)`. + - `shell_reveal_in_finder(path)` — reject non-absolute, then call `reveal_in_finder_inner(path)`. + - `pub(crate) fn reveal_in_finder_inner(path: &Path) -> AppResult<()>` — `#[cfg(target_os = "macos")]` runs `open -R `; non-mac branch returns `AppError::Validation("reveal in finder is macOS-only in v1")`. + - Replace `commands/dialog.rs` stubs with real impl per plan Step 12.2: + - `dialog_choose_folder(app, title) -> Option` — `app.dialog().file().pick_folder(...)` with `std::sync::mpsc` bridge. + - `dialog_choose_files(app, title, filters) -> Vec` — `pick_files(...)`. + - Register `tauri-plugin-dialog` in `lib.rs::run` per plan Step 12.3 (`.plugin(tauri_plugin_dialog::init())`). + - Update `capabilities/default.json` per plan Step 12.4 — add the dialog plugin's permission set (`dialog:default` or equivalent). + +### Methodology — verification-driven + +1. **Invoke `superpowers:using-superpowers`** first. TDD is not the methodology for this phase — the commands are thin wrappers and the underlying logic was tested in Phases A-D. Verification is via `cargo check`, `cargo clippy`, and Phase G's runtime smoke. +2. **Two commits — one per task.** +3. For Task 11: + - Step 11.1: paste plan's `commands/vault.rs` verbatim (lines ~3035–3395). It has 13 commands + 1 helper (`now_iso`) + 6 input/output structs. + - Step 11.2: rewrite `commands/mod.rs` to expose 4 modules. + - Step 11.3: register 23 commands in `lib.rs::run`'s `invoke_handler`. + - Step 11.4: stub `commands/shell.rs` and `commands/dialog.rs` per plan Step 11.4 (signatures + `Ok(())` bodies, plus `reveal_in_finder_inner` private helper). + - Step 11.5: `cargo check && cargo clippy -- -D warnings` → both pass. + - Step 11.6: commit `m3(commands): vault_* command surface (open/close/list/read/write/...) + shell/dialog stubs`. +4. For Task 12: + - Step 12.1: replace `commands/shell.rs` per plan (lines ~3522–3590). + - Step 12.2: replace `commands/dialog.rs` per plan (lines ~3593–3635). + - Step 12.3: add `.plugin(tauri_plugin_dialog::init())` to the Builder chain in `lib.rs::run`. + - Step 12.4: edit `capabilities/default.json` to grant dialog permissions. + - Step 12.5: `cargo check && cargo clippy -- -D warnings && cargo test --features test-helpers` → all pass; no new tests. + - Step 12.6: manual smoke — `pnpm dev`, click a button that triggers `dialog_choose_folder`, confirm picker opens. (Optional in Phase E; required in Phase G's manual smoke.) + - Step 12.7: commit `m3(commands): shell + dialog real impl + tauri-plugin-dialog wired`. + +### Critical gotchas + +1. **`vault_open` flow ordering matters:** + ``` + validate_dir → preferences::init_vault → set_indexing(true, 0) + → drop_existing_watcher → set_current → count_notes → upsert+touch_registry + → start_watcher → spawn_event_forwarder → set_indexing(false, 100) + → emit vault-status-changed → return success + ``` + Reordering breaks acceptance tests. Plan Step 11.1 lays this out exactly. Match step-by-step. +2. **Watcher slot lock scope:** Each `watcher_slot.lock()` runs in its own short block. **Never hold the lock across `await`** — Plan's impl uses `{ let mut slot = ...; *slot = Some(handle); }` then drops the guard before `tokio::spawn(...)`. Holding across the spawn would deadlock the next `vault_close` call. +3. **Event forwarder runs forever per vault open:** `tokio::spawn(async move { while let Some(event) = rx.recv().await { app_handle.emit(...); } })`. The receiver `rx` is held by the spawn task; when the watcher handle drops, `tx` drops, `rx.recv()` returns `None`, the loop exits. Don't add `if cancel { break }` — the channel close is the signal. +4. **`vault_switch` is just `vault_open`:** It exists for renderer ergonomics. Plan delegates it: `vault_switch(...) -> vault_open(state, app, VaultOpenInput { path: input.path }).await`. No additional logic. +5. **`vault_remove` close-if-current:** Compares `current.to_string_lossy()` to `input.path`. If match, `vault_close(state.clone(), app.clone()).await` first. **`State<'_, T>` is NOT clonable** — `state.clone()` would fail. The fix: pass the cloned `Arc` in via the dereference, OR re-fetch state in vault_close. Plan's impl uses `state.clone()` because `State<'_, T>` does have a `clone()` for the `tauri::State` smart-pointer — verify this compiles. If it doesn't, refactor to `vault_close_inner(state.vault.clone(), app.clone())` taking `Arc`. +6. **`vault_reindex` is a permanent stub for M3:** Returns `{ success: true, filesIndexed: 0, duration: 0, deferredUntil: "M7" }`. Phase G's `command:parity` audit must classify this as `deferred:M7`. Don't accidentally implement real reindex. +7. **`vault_reveal` reuses `shell::reveal_in_finder_inner`:** That helper is `pub(crate)` in `shell.rs` (Task 12). Phase E Task 11 stubs it returning `Ok(())` — Task 12 replaces it. The cross-module call is intentional; vault.rs depends on shell.rs. +8. **Stubs in Task 11 must match Task 12 signatures:** `shell_open_url(_url: String)` not `(_app, _url)`. `shell_open_path(_path: String)`. `shell_reveal_in_finder(_path: String)`. `dialog_choose_folder(_title: Option)`. `dialog_choose_files(_title: Option, _filters: Option>)`. Matching signatures keep the `generate_handler!` registration stable across the two commits. +9. **`reveal_in_finder_inner` cfg-gating:** `#[cfg(target_os = "macos")]` for the `open -R` impl. The `#[cfg(not(target_os = "macos"))]` branch returns `Err(AppError::Validation(...))`. Don't omit the non-mac branch — `cargo check --target x86_64-unknown-linux-gnu` would fail in CI. +10. **`tauri-plugin-dialog` registration order:** Plan Step 12.3 adds `.plugin(tauri_plugin_dialog::init())` to the Builder chain. `tauri-plugin-shell` was already registered in M2. Order in the chain is: `default()` → `.plugin(shell)` → `.plugin(dialog)` → `.invoke_handler(...)` → `.setup(...)`. Standard Tauri 2 chain ordering. +11. **Capabilities for dialog:** Tauri 2 plugins need explicit capability grants. Edit `capabilities/default.json` to add the dialog permission set. Schema: `"dialog:default"` typically grants `pick_folder` and `pick_files`. Run `pnpm --filter @memry/desktop-tauri capability:check` to verify. +12. **`shell_open_url` URL allowlist:** Plan's impl rejects non-http(s) via prefix check. Don't expand to `mailto:`, `tel:`, etc. — that bypasses the URL escape guard. If renderer needs other schemes, M8 lifecycle layer will add explicit support. +13. **`dialog_choose_*` blocking bridge:** The dialog API is callback-based; plan uses `std::sync::mpsc::channel()` to bridge to async. The `tx.send(...)` in the callback is sync; `rx.recv()` blocks the async runtime briefly. Acceptable because the user is interacting with the OS picker — the runtime will wait. **Don't replace with `tokio::sync::mpsc`** — the dialog callback runs on a non-Tokio thread. +14. **`commands/mod.rs` must come BEFORE `lib.rs` references:** Without `pub mod vault;` in `commands/mod.rs`, the `commands::vault::*` paths in `lib.rs` won't resolve. Step 11.2 is structural; don't skip. +15. **No new tests for vault commands in this phase:** Phase G adds `m3-vault-smoke.spec.ts` against the real Tauri runtime. Adding Rust integration tests for `vault_open` would require booting Tauri inside a test, which is non-trivial. Plan defers that to runtime e2e. + +### Constraints + +- **No scope creep:** Do not implement `memry-file://` protocol, drag-drop spike, bindings regen, mock-swap, or runtime e2e in Phase E. Phase F + Phase G handle them. +- **No modifications to vault::* modules:** `vault::fs`, `vault::frontmatter`, `vault::notes_io`, `vault::preferences`, `vault::registry`, `vault::state`, `vault::watcher` are FROZEN by Phase E. Adding a new public function there is scope creep — Phase E should only call existing surface. +- **No new commands beyond M3 deliverables list:** 13 vault + 3 shell + 2 dialog = 18 commands. Don't add `vault_create_folder`, `vault_rename_note`, etc. — those are M5. +- **No mock changes:** `apps/desktop-tauri/src/lib/ipc/mocks/vault.ts` stays frozen in Phase E. Phase G trims it after bindings regen. +- **`cargo clippy -- -D warnings`** clean at each task boundary. +- **No Specta type registration here:** Phase G's `bin/generate_bindings.rs` adds the `.typ::<...>()` calls. Phase E commands use Specta proc-macros (`#[specta::specta]`) but don't touch the binding generator. + +### Acceptance criteria (Phase E done when all pass) + +```bash +cd /Users/h4yfans/sideproject/memry-worktrees/spike-tauri-m3 + +# Files implemented +test -f apps/desktop-tauri/src-tauri/src/commands/vault.rs +test -f apps/desktop-tauri/src-tauri/src/commands/shell.rs +test -f apps/desktop-tauri/src-tauri/src/commands/dialog.rs +[ "$(wc -l < apps/desktop-tauri/src-tauri/src/commands/vault.rs)" -gt 250 ] +[ "$(wc -l < apps/desktop-tauri/src-tauri/src/commands/shell.rs)" -gt 30 ] +[ "$(wc -l < apps/desktop-tauri/src-tauri/src/commands/dialog.rs)" -gt 30 ] + +# commands/mod.rs declares 4 modules +grep -q '^pub mod settings;' apps/desktop-tauri/src-tauri/src/commands/mod.rs +grep -q '^pub mod vault;' apps/desktop-tauri/src-tauri/src/commands/mod.rs +grep -q '^pub mod shell;' apps/desktop-tauri/src-tauri/src/commands/mod.rs +grep -q '^pub mod dialog;' apps/desktop-tauri/src-tauri/src/commands/mod.rs + +# 18 commands registered in lib.rs invoke_handler (settings 3 + vault 15 + shell 3 + dialog 2 = 23) +grep -c 'commands::vault::vault_' apps/desktop-tauri/src-tauri/src/lib.rs # expect ≥ 15 +grep -c 'commands::shell::shell_' apps/desktop-tauri/src-tauri/src/lib.rs # expect ≥ 3 +grep -c 'commands::dialog::dialog_' apps/desktop-tauri/src-tauri/src/lib.rs # expect ≥ 2 + +# tauri-plugin-dialog registered +grep -q 'tauri_plugin_dialog::init' apps/desktop-tauri/src-tauri/src/lib.rs + +# Capabilities updated +grep -q 'dialog' apps/desktop-tauri/src-tauri/capabilities/default.json + +# Rust hygiene +pnpm --filter @memry/desktop-tauri cargo:check +pnpm --filter @memry/desktop-tauri cargo:clippy +pnpm --filter @memry/desktop-tauri capability:check + +# All prior tests still green (no new tests in Phase E) +cd apps/desktop-tauri/src-tauri && cargo test --features test-helpers 2>&1 | tail -3 +# expect: ~78 passed (no delta from Phase D) + +# Commits +cd /Users/h4yfans/sideproject/memry-worktrees/spike-tauri-m3 +git log --oneline | grep -cE 'm3\(commands\)' # expect ≥ 2 + +# Electron / packages / specs / plans untouched +git diff --name-only main..HEAD -- apps/desktop/ apps/sync-server/ packages/ docs/superpowers/specs/ docs/superpowers/plans/ | wc -l +# expect 0 +``` + +### When done + +Report to user: + +``` +Phase E complete. +Tasks covered: 11, 12 +Commits: 2 (..) +Rust tests: 0 new (verification-driven phase) — total still ~78 passed +Verification: + - cargo check: clean + - cargo clippy -- -D warnings: clean + - cargo test --features test-helpers: 78 passed, 0 failed + - capability:check: clean + - 23 commands registered in lib.rs invoke_handler (15 vault + 3 shell + 2 dialog + 3 settings) + - tauri-plugin-dialog wired + - capabilities/default.json updated + - Electron/packages/specs/plans untouched: 0 files + +Next: Phase F — prompts/m3/m3-phase-f-protocol-and-dragdrop.md +Blockers: +``` + +If blocker: +- `cargo check` complains "no function `state.clone()`" → `tauri::State<'_, T>` does have `Clone`; if your version doesn't, refactor `vault_remove` to call `vault_close_inner(Arc, AppHandle)` instead of `vault_close(state, app)`. +- Specta complains about `frontmatter::NoteFrontmatter` → check that `vault/mod.rs` re-exports it (Phase D Step 9.2). Without the re-export, `commands::vault::vault.rs::use crate::vault::frontmatter::NoteFrontmatter;` works but `bindings.rs` Phase G `.typ::()` does too — both should work in parallel. +- `tauri::generate_handler!` complains about a missing command → check the macro list; you may have a typo. The list must EXACTLY match the function names in their respective modules. +- `capability:check` fails → the dialog permission identifier may have changed in the Tauri 2 plugin version. Check `apps/desktop-tauri/src-tauri/gen/schemas/desktop-schema.json` for the actual permission name. + +If still blocked: invoke `superpowers:systematic-debugging`. Report + wait for approval. + +### Ready + +1. Invoke `superpowers:using-superpowers`. +2. Read plan Tasks 11, 12 fully (lines ~3024–3735 of the plan file). +3. Run prerequisite verification. Report results. +4. Task 11: + - Paste `commands/vault.rs` verbatim from plan Step 11.1. + - Update `commands/mod.rs`. + - Register 23 commands in `lib.rs::run`. + - Stub `commands/shell.rs` and `commands/dialog.rs` per Step 11.4. + - `cargo check && cargo clippy -- -D warnings`. + - Commit `m3(commands): vault_* command surface (open/close/list/read/write/...) + shell/dialog stubs`. +5. Task 12: + - Replace `commands/shell.rs` with real impl. + - Replace `commands/dialog.rs` with real impl. + - Wire `tauri-plugin-dialog` in `lib.rs::run`. + - Update `capabilities/default.json`. + - `cargo check && cargo clippy -- -D warnings && cargo test --features test-helpers && capability:check`. + - Commit `m3(commands): shell + dialog real impl + tauri-plugin-dialog wired`. + +## PROMPT END diff --git a/prompts/m3/m3-phase-f-protocol-and-dragdrop.md b/prompts/m3/m3-phase-f-protocol-and-dragdrop.md new file mode 100644 index 000000000..14d6abc07 --- /dev/null +++ b/prompts/m3/m3-phase-f-protocol-and-dragdrop.md @@ -0,0 +1,247 @@ +# M3 Phase F — Protocol + Drag-Drop Spike (memry-file:// + drag-drop event) + +Temiz session prompt. Verification + manuel smoke driven phase. Bu phase Electron'un `memry-file://` ve `File.path` sürümlerinin Tauri replacement'ı. + +--- + +## PROMPT START + +You are implementing **Phase F of Milestone M3** for Memry's Electron→Tauri migration. This phase lands two desktop-app integrations that the spec calls out as M3 cross-cutting deliverables: (1) the `memry-file://` custom URI scheme protocol handler — a vault-allowlisted, byte-range-aware, missing-image-fallback file server that replaces Electron's `protocol.registerFileProtocol`; (2) a documented drag-drop path-resolution spike that proves Tauri 2 + macOS WebKit deliver real `/Users/...` paths on file drop, replacing Electron's `webUtils.getPathForFile`. + +### Context + +**Worktree:** `/Users/h4yfans/sideproject/memry-worktrees/spike-tauri-m3` +**Branch:** `m3/vault-fs-and-watcher` +**Plan:** `docs/superpowers/plans/2026-04-26-m3-vault-fs-and-watcher.md` +**Spec:** `docs/superpowers/specs/2026-04-24-electron-to-tauri-full-migration-design.md` +**Prompts README:** `prompts/m3/README.md` + +Phase A-E landed deps + paths + fs/frontmatter/notes_io + preferences/registry + watcher + state/AppState + 23 commands (78 tests, 18 commands). Phase F adds the URI scheme protocol handler in `lib.rs::run` and subscribes to the main window's drag-drop event. The drag-drop spike emits a renderer console log so manual verification can prove paths come through. Phase G removes the spike telemetry once the smoke is documented in `scripts/drag-drop-smoke.md`. + +### Prerequisite verification + +```bash +cd /Users/h4yfans/sideproject/memry-worktrees/spike-tauri-m3 +git rev-parse --abbrev-ref HEAD # expect: m3/vault-fs-and-watcher + +# Phase E complete +test -f apps/desktop-tauri/src-tauri/src/commands/vault.rs +test -f apps/desktop-tauri/src-tauri/src/commands/shell.rs +test -f apps/desktop-tauri/src-tauri/src/commands/dialog.rs +[ "$(wc -l < apps/desktop-tauri/src-tauri/src/commands/vault.rs)" -gt 250 ] +grep -q 'tauri_plugin_dialog::init' apps/desktop-tauri/src-tauri/src/lib.rs +grep -q 'commands::vault::vault_open' apps/desktop-tauri/src-tauri/src/lib.rs + +# Tests still green +pnpm --filter @memry/desktop-tauri cargo:check +pnpm --filter @memry/desktop-tauri cargo:clippy +pnpm --filter @memry/desktop-tauri capability:check +cd apps/desktop-tauri/src-tauri && cargo test --features test-helpers 2>&1 | tail -3 +# expect: ~78 passed (no delta from Phase D; Phase E added no tests) + +cd /Users/h4yfans/sideproject/memry-worktrees/spike-tauri-m3 +git log --oneline | grep -cE 'm3\(commands\)' # expect ≥ 2 + +# Scratch test vault has at least one image (we'll smoke it later) +ls ~/memry-test-vault-m3/attachments/images/ 2>/dev/null || mkdir -p ~/memry-test-vault-m3/attachments/images/ +``` + +If any fails, STOP. Phase E must complete before Phase F starts. + +### Your scope + +Execute **Tasks 13, 14** from the plan in this order. + +- **Task 13 — `memry-file://` URI scheme handler**: + - Step 13.1: update `tauri.conf.json` `app.security.csp` to add `memry-file:` to `default-src`, `img-src`, and `media-src`. Plan provides the exact CSP string. + - Step 13.2: add `urlencoding = "2.1"` to `Cargo.toml` `[dependencies]`. + - Step 13.3: implement the protocol handler in `lib.rs`: + - `.register_uri_scheme_protocol("memry-file", |ctx, request| { handle_memry_file(&ctx.app_handle().clone(), &request) })` — added to the Builder chain after `.plugin(tauri_plugin_dialog::init())`. + - `handle_memry_file(app, request)` function: parse `memry-file://local/` URL → percent-decode → canonicalize → check vault-root + app-data-dir allowlist → 403 if outside → read bytes → MIME-guess → handle `Range:` header for partial content (206) → return 200 with full bytes otherwise. + - `missing(path)` fallback: if the path looks like an image (.png/.jpg/.jpeg/.gif/.webp), return 200 + `image/png` + a 1×1 transparent PNG. Otherwise return 404. + - `parse_range(header_value, total)` helper. + - `base64_decode_static(input)` for the embedded 1×1 PNG. + - Step 13.4: create `apps/desktop-tauri/src/lib/memry-file.ts` with `toMemryFileUrl(absolutePath)` and `fromMemryFileUrl(url)` helpers. + - Step 13.5: manual smoke — drop a real image in the scratch vault, build dev mode, verify image loads, missing image returns 1×1 PNG, outside-vault path returns 403. + - Step 13.7: commit `m3(protocol): memry-file:// URI scheme with byte-range + missing-image fallback`. + +- **Task 14 — Drag-drop path-resolution spike**: + - Step 14.1: confirm `core:default` includes file-drop event grants. Inspect `gen/schemas/desktop-schema.json` for `dragDropEvent` / `drop` references. Add `core:webview:allow-on-drag-drop-event` to `capabilities/default.json` if absent. + - Step 14.2: subscribe to the main window's `WindowEvent::DragDrop` in `lib.rs::run`'s `.setup(...)` closure. On `DragDropEvent::Drop { paths, .. }`, emit `vault-drag-drop` event to the renderer with `Vec` (paths converted via `to_string_lossy().into_owned()`). + - Step 14.3: temporary spike telemetry in `apps/desktop-tauri/src/main.tsx` — `listen('vault-drag-drop', (event) => console.info('[drag-drop spike] paths:', event.payload))`. This block is REMOVED in Phase G Task 16.5; here we just add it. + - Step 14.4: manual smoke — `pnpm dev`, drag image/PDF/video into the window, verify dev console logs real `/Users/...` paths. If you see `webkit-fake-url://`, the smoke is 🔴 — document the fallback to `dialog_choose_files`. + - Step 14.5: create `apps/desktop-tauri/scripts/drag-drop-smoke.md` documenting the smoke, outcomes table, and last-verified date/version. + - Step 14.6: commit `m3(spike): drag-drop path resolution + documented fallback to dialog picker`. + +### Methodology — verification + manual smoke + +1. **Invoke `superpowers:using-superpowers`** first. No TDD this phase — protocol handlers and window events aren't unit-testable cleanly. +2. **Two commits — one per task.** +3. For Task 13: + - Step 13.1: edit `tauri.conf.json` CSP. + - Step 13.2: add `urlencoding` dep. + - Step 13.3: paste the protocol handler verbatim from plan (lines ~3762–3927). The handler is ~165 lines. Note that `register_uri_scheme_protocol`'s callback signature requires moving `app` into the closure carefully — the plan's exact pattern uses `let app = ctx.app_handle().clone();` then passes `&app` to `handle_memry_file`. + - Step 13.4: create `memry-file.ts` helper. + - Step 13.5: manual smoke with a real image drop test. + - Step 13.7: commit. +4. For Task 14: + - Step 14.1: capability inspection (read-only `grep`). + - Step 14.2: edit `lib.rs::run` to subscribe to drag-drop. Plan provides the exact closure pattern using `WindowEvent::DragDrop` + `DragDropEvent::Drop { paths, .. }`. + - Step 14.3: edit `main.tsx` — add the temporary `listen` call. + - Step 14.4: manual smoke. Capture the console output for the PR body. + - Step 14.5: write `scripts/drag-drop-smoke.md` per plan template. + - Step 14.6: commit. + +### Critical gotchas + +1. **CSP regression risk:** `tauri.conf.json::app.security.csp` already has the M2 baseline. Plan Step 13.1 modifies ONLY the `default-src`, `img-src`, and `media-src` directives — adding `memry-file:` to each. Other directives (`script-src`, `style-src`, `frame-src`, `font-src`, `worker-src`, `connect-src`) MUST be preserved verbatim. Re-read the plan's CSP string and diff against the current file before saving. +2. **`withGlobalTauri` doesn't matter for protocols:** Plan's draft mentions `"withGlobalTauri": false` but in Tauri 2 the URI scheme registration happens via `register_uri_scheme_protocol` in `lib.rs::run`, not in conf JSON. Plan corrects this in the same step ("wait, in Tauri 2 ..."). Don't add `withGlobalTauri` to conf. +3. **Path canonicalization is critical for the allowlist:** `dunce::canonicalize(&path)` BEFORE the `starts_with` allowlist check. Without canonicalization, `memry-file://local/Users/me/memry-test-vault-m3/../../../etc/passwd` would slip through the prefix check. The canonicalize resolves `..` and any symlinks first. +4. **Allowlist roots:** Vault root (from `state.vault.current_path()`) AND app-data dir (`directories::ProjectDirs::from(...).data_dir()`). The app-data inclusion is for future thumbnails / cached attachments. Don't drop it. +5. **`missing` fallback ONLY for images:** Plan's `missing` function checks the URL extension. `.png/.jpg/.jpeg/.gif/.webp` → 1×1 transparent PNG (so `` tags don't break-icon). Other types → 404. Don't expand to PDFs or video — those have proper UI fallbacks. +6. **`parse_range` saturating bounds:** Plan's impl uses `total.saturating_sub(1)` for the empty-end case (`Range: bytes=100-`). Don't use `total - 1` — would underflow if `total == 0`. +7. **`base64_decode_static` is hand-rolled:** Plan implements base64 inline because adding `base64` crate just for the 100-byte 1×1 PNG is overkill. Don't replace with `base64::decode(...)` — that's an unnecessary dep. +8. **`urlencoding` dep is needed:** Plan Step 13.3 uses `urlencoding::decode(p)` for percent-decoded paths. Without `urlencoding = "2.1"` in `Cargo.toml`, `cargo check` fails. Step 13.2 adds it. +9. **`memry-file.ts` `replace(/^\/+/, '')`:** The Tauri URI scheme handler reconstructs the absolute path as `/${decoded}`. So `toMemryFileUrl` strips leading slashes from the input first — `/Users/.../foo.png` → `Users/.../foo.png` → URL = `memry-file://local/Users/.../foo.png`. Don't double-slash. +10. **`encodeURI` not `encodeURIComponent`:** `toMemryFileUrl` uses `encodeURI` to preserve `/` in path segments. `encodeURIComponent` would percent-encode the slashes and break the path on the Rust side. +11. **`fromMemryFileUrl` decoder:** Mirrors `toMemryFileUrl` — strip the `memry-file://local/` prefix, `decodeURIComponent` the rest, prepend `/`. Used for renderer-side display logic if a route shows the original path. +12. **Drag-drop event signature:** Tauri 2 `WindowEvent::DragDrop` wraps `DragDropEvent` which has variants `Enter`, `Over`, `Drop`, `Leave`. The plan only handles `Drop { paths, .. }`. The `paths` field is `Vec`. The closure must `iter().map(|p| p.to_string_lossy().into_owned()).collect()` to produce `Vec` for the event payload — Tauri's `Emitter` serializes via Serde. +13. **`anyhow` dep already in Cargo.toml or not:** Plan Step 14.2's closure body uses `anyhow::anyhow!("main window missing")`. If `anyhow` isn't already a dep, add `anyhow = "1"`. Spike-only usage; remove if you can refactor without it (e.g., use `eyre` or just `Box::::from(...)` directly). Plan's note: "Add `anyhow = \"1\"` to `[dependencies]` if not already present." +14. **Drag-drop spike telemetry must be REMOVED in Phase G:** The `void listen('vault-drag-drop', ...)` block in `main.tsx` is a one-shot verification import. Phase G Task 16.5 deletes it. Phase F adds it; Phase G removes it. Don't preemptively delete it here. +15. **`scripts/drag-drop-smoke.md` is a **plain markdown** file:** Plan Step 14.5 supplies the exact template. Fill in `` and `` after running the smoke. Don't include the dev console image / video — markdown text only. +16. **Capability schema changes are surfaced in `desktop-schema.json`:** Plan Step 14.1 says inspect the schema for `dragDropEvent`. The Tauri 2 default capability set usually grants this; verify before adding. Adding redundant grants is fine but `capability:check` may flag duplicates. +17. **Manual smoke is REQUIRED, not optional:** Phase F's correctness depends on macOS-specific behaviors (FSEvents-rooted protocol handling, WebKit drop event delivery). Run the smokes; record output. Phase G's PR body includes the smoke results — don't skip. + +### Constraints + +- **No scope creep:** Do not regenerate Specta bindings, swap mock IPC, run the e2e suite, or open a PR in Phase F. Phase G handles all of that. +- **No vault module changes:** `vault::*` is FROZEN. Phase F only touches `lib.rs`, `tauri.conf.json`, `Cargo.toml`, `capabilities/default.json`, and renderer `main.tsx` + new `lib/memry-file.ts`. +- **No new commands:** The protocol handler is NOT a Tauri command — it's a URI scheme handler registered on the Builder. Don't `#[tauri::command]` it. +- **No behavior changes to existing commands:** `vault_open` may need to coexist with the protocol handler reading the current vault path; verify the lock semantics still hold (`state.vault.current_path()` is a brief lock, fine to call from the protocol thread). +- **No expanded CSP beyond `memry-file:`:** Don't add `https://*.cdn.com` or any third-party origin. The CSP narrowing is part of the security review. +- **No new tests:** Phase F adds no Rust integration tests. Manual smoke is the verification method; Phase G's runtime e2e covers `vault_*` paths but not the protocol handler. + +### Acceptance criteria (Phase F done when all pass) + +```bash +cd /Users/h4yfans/sideproject/memry-worktrees/spike-tauri-m3 + +# Files modified +grep -q 'memry-file:' apps/desktop-tauri/src-tauri/tauri.conf.json +grep -q 'register_uri_scheme_protocol' apps/desktop-tauri/src-tauri/src/lib.rs +grep -q 'fn handle_memry_file' apps/desktop-tauri/src-tauri/src/lib.rs +grep -q 'fn missing' apps/desktop-tauri/src-tauri/src/lib.rs +grep -q 'fn parse_range' apps/desktop-tauri/src-tauri/src/lib.rs +grep -q 'fn base64_decode_static' apps/desktop-tauri/src-tauri/src/lib.rs + +# urlencoding dep +grep -q '^urlencoding' apps/desktop-tauri/src-tauri/Cargo.toml + +# memry-file.ts helper +test -f apps/desktop-tauri/src/lib/memry-file.ts +grep -q 'toMemryFileUrl' apps/desktop-tauri/src/lib/memry-file.ts +grep -q 'fromMemryFileUrl' apps/desktop-tauri/src/lib/memry-file.ts + +# Drag-drop wiring +grep -q 'vault-drag-drop' apps/desktop-tauri/src-tauri/src/lib.rs +grep -q 'DragDrop' apps/desktop-tauri/src-tauri/src/lib.rs +grep -q "vault-drag-drop" apps/desktop-tauri/src/main.tsx +grep -q "drag-drop spike" apps/desktop-tauri/src/main.tsx + +# Spike documentation +test -f apps/desktop-tauri/scripts/drag-drop-smoke.md +[ "$(wc -l < apps/desktop-tauri/scripts/drag-drop-smoke.md)" -gt 5 ] + +# Rust hygiene +pnpm --filter @memry/desktop-tauri cargo:check +pnpm --filter @memry/desktop-tauri cargo:clippy +pnpm --filter @memry/desktop-tauri capability:check +pnpm --filter @memry/desktop-tauri typecheck + +# All prior tests still green +cd apps/desktop-tauri/src-tauri && cargo test --features test-helpers 2>&1 | tail -3 +# expect: ~78 passed + +# Manual smoke evidence — capture in user report +# 1. Real image at `~/memry-test-vault-m3/attachments/images/test.png` loads via memry-file:// +# 2. Missing image at `notes/missing.png` returns 1×1 transparent PNG (no broken-image icon) +# 3. Outside-vault path `/etc/hosts` returns 403 +# 4. Drag image+pdf+mp4 from Finder into window — dev console logs real `/Users/...` paths + +# Commits +cd /Users/h4yfans/sideproject/memry-worktrees/spike-tauri-m3 +git log --oneline | grep -cE 'm3\((protocol|spike)\)' # expect ≥ 2 + +# Electron / packages / specs / plans untouched +git diff --name-only main..HEAD -- apps/desktop/ apps/sync-server/ packages/ docs/superpowers/specs/ docs/superpowers/plans/ | wc -l +# expect 0 +``` + +### When done + +Report to user (include manual smoke results): + +``` +Phase F complete. +Tasks covered: 13, 14 +Commits: 2 (..) +Rust tests: 0 new — total still ~78 passed +Verification: + - cargo check: clean + - cargo clippy -- -D warnings: clean + - capability:check: clean + - typecheck: clean + - cargo test --features test-helpers: 78 passed, 0 failed + +Manual smoke (memry-file://): + - real image renders: 🟢 + - missing image → 1×1 PNG fallback: 🟢 + - outside-vault path → 403: 🟢 + +Manual smoke (drag-drop): + - drop image+pdf+mp4 from Finder → real paths: 🟢 (or 🔴 fallback documented) + +Documents: + - apps/desktop-tauri/scripts/drag-drop-smoke.md: ✓ filled with date and macOS + +Spike telemetry: + - main.tsx still has the temporary `listen('vault-drag-drop', ...)` block (Phase G Task 16.5 removes it) + +Electron/packages/specs/plans untouched: 0 files + +Next: Phase G — prompts/m3/m3-phase-g-bindings-renderer-bench-pr.md +Blockers: +``` + +If blocker: +- Image fails to load via `memry-file://` → check the CSP `img-src` includes `memry-file:`. Open DevTools > Network and verify the response status. 403 means allowlist mismatch — `state.vault.current_path()` returned `None` (vault not open) or the path is outside the canonicalized vault root. +- 1×1 PNG fallback fails → `base64_decode_static` returned wrong bytes. The hardcoded base64 string in plan Step 13.3's `missing` function decodes to a valid 67-byte transparent PNG. Verify by decoding manually: `echo "iVBORw0KG..." | base64 -d | file -` should report `PNG image data, 1 x 1`. +- Drop event delivers `webkit-fake-url://` instead of real paths → expected on older macOS WebKit; **don't fail Phase F**. Document the 🔴 outcome in `drag-drop-smoke.md` and Phase G's M8 file-import work uses `dialog_choose_files` as the canonical fallback (already implemented in Phase E). +- `register_uri_scheme_protocol` signature mismatch → Tauri 2's protocol handler closure signature changes between minor versions. The plan targets Tauri 2.10. Check `apps/desktop-tauri/src-tauri/Cargo.toml` for the Tauri version. If you're on a newer minor, the signature might be `|ctx, request, responder|` — in that case, call `responder.respond(response)` instead of returning the response. +- `capability:check` fails after drag-drop change → ensure `capabilities/default.json` keeps the JSON structure valid; missing comma is the usual culprit. + +If still blocked: invoke `superpowers:systematic-debugging`. Report + wait for approval. + +### Ready + +1. Invoke `superpowers:using-superpowers`. +2. Read plan Tasks 13, 14 fully (lines ~3735–4108 of the plan file). +3. Run prerequisite verification. Report results. +4. Task 13: + - Update `tauri.conf.json` CSP. + - Add `urlencoding` dep. + - Paste protocol handler in `lib.rs` (handle_memry_file + missing + parse_range + base64_decode_static). + - Add `register_uri_scheme_protocol("memry-file", ...)` to Builder chain. + - Create `apps/desktop-tauri/src/lib/memry-file.ts`. + - Manual smoke: real image renders, missing image returns 1×1 PNG, outside-vault returns 403. + - Commit `m3(protocol): memry-file:// URI scheme with byte-range + missing-image fallback`. +5. Task 14: + - Inspect/grant drag-drop capability. + - Subscribe to `WindowEvent::DragDrop` in `lib.rs::run::setup` and emit `vault-drag-drop` event. + - Add temporary `listen` block in `main.tsx`. + - Add `anyhow = "1"` if not present. + - Manual smoke: drop files into window, verify console output. + - Create `scripts/drag-drop-smoke.md` documenting outcomes table + verification date. + - Commit `m3(spike): drag-drop path resolution + documented fallback to dialog picker`. + +## PROMPT END diff --git a/prompts/m3/m3-phase-g-bindings-renderer-bench-pr.md b/prompts/m3/m3-phase-g-bindings-renderer-bench-pr.md new file mode 100644 index 000000000..3f39a2138 --- /dev/null +++ b/prompts/m3/m3-phase-g-bindings-renderer-bench-pr.md @@ -0,0 +1,286 @@ +# M3 Phase G — Bindings + Renderer Mock-Swap + Runtime e2e + Bench + PR + +Temiz session prompt. Bu phase M3'ün son halkası: Specta bindings regen, mock'tan gerçek invoke'a swap, runtime e2e smoke, 100-note bench, acceptance gate, PR open. M3 closure phase. + +--- + +## PROMPT START + +You are implementing **Phase G of Milestone M3** for Memry's Electron→Tauri migration. This is the closing phase: regenerate Specta TypeScript bindings to expose every M3 type and command, swap the renderer's mock IPC routes to real Rust for the 22 M3 commands (keeping `vault_reindex` and `vault_create` as documented deferrals), add a runtime e2e Playwright smoke that exercises `vault_open` / `vault_list_notes` / `vault_read_note` / `vault_write_note` end-to-end, write the 100-note `<500ms` performance bench, run the full acceptance gate, push the branch, and open the M3 PR. + +### Context + +**Worktree:** `/Users/h4yfans/sideproject/memry-worktrees/spike-tauri-m3` +**Branch:** `m3/vault-fs-and-watcher` +**Plan:** `docs/superpowers/plans/2026-04-26-m3-vault-fs-and-watcher.md` +**Spec:** `docs/superpowers/specs/2026-04-24-electron-to-tauri-full-migration-design.md` +**Prompts README:** `prompts/m3/README.md` + +Phase A-F landed deps + paths + fs/frontmatter/notes_io + preferences/registry + watcher + state/AppState + 23 commands + memry-file:// + drag-drop spike (78 vault tests, 18 commands, 1 protocol handler). Phase G shows that work to the renderer, runs a runtime e2e smoke, proves the 100-note bench, removes the spike telemetry, and ships the PR. + +### Prerequisite verification + +```bash +cd /Users/h4yfans/sideproject/memry-worktrees/spike-tauri-m3 +git rev-parse --abbrev-ref HEAD # expect: m3/vault-fs-and-watcher + +# Phase F complete +grep -q 'register_uri_scheme_protocol' apps/desktop-tauri/src-tauri/src/lib.rs +grep -q 'fn handle_memry_file' apps/desktop-tauri/src-tauri/src/lib.rs +grep -q 'vault-drag-drop' apps/desktop-tauri/src-tauri/src/lib.rs +test -f apps/desktop-tauri/src/lib/memry-file.ts +test -f apps/desktop-tauri/scripts/drag-drop-smoke.md +grep -q 'memry-file:' apps/desktop-tauri/src-tauri/tauri.conf.json +grep -q 'drag-drop spike' apps/desktop-tauri/src/main.tsx # spike telemetry still present + +# Tests still green +pnpm --filter @memry/desktop-tauri cargo:check +pnpm --filter @memry/desktop-tauri cargo:clippy +pnpm --filter @memry/desktop-tauri capability:check +pnpm --filter @memry/desktop-tauri typecheck +cd apps/desktop-tauri/src-tauri && cargo test --features test-helpers 2>&1 | tail -3 +# expect: ~78 passed + +cd /Users/h4yfans/sideproject/memry-worktrees/spike-tauri-m3 +git log --oneline | grep -cE 'm3\((deps|vault|commands|protocol|spike)\)' # expect ≥ 13 + +# Scratch test vault exists for runtime e2e (used by M3_TEST_VAULT_PATH) +test -d ~/memry-test-vault-m3 +``` + +If any fails, STOP. Phase F must complete before Phase G starts. + +### Your scope + +Execute **Tasks 15, 16** from the plan in this order. + +- **Task 15 — Bindings regen + mock-swap + renderer integration**: + - Step 15.1: extend `apps/desktop-tauri/src-tauri/src/bin/generate_bindings.rs` per plan. Add 23 commands to `collect_commands![...]` and 13+ vault `.typ::<...>()` calls. Plan's exact list lives at lines ~4126–4185. + - Step 15.2: regen + verify with `pnpm --filter @memry/desktop-tauri bindings:generate && pnpm --filter @memry/desktop-tauri bindings:check`. + - Step 15.3: extend `realCommands` Set in `apps/desktop-tauri/src/lib/ipc/invoke.ts` to include the 22 M3 commands (vault_open, vault_close, vault_get_status, vault_get_current, vault_get_all, vault_switch, vault_remove, vault_get_config, vault_update_config, vault_list_notes, vault_read_note, vault_write_note, vault_delete_note, vault_reveal, shell_open_url, shell_open_path, shell_reveal_in_finder, dialog_choose_folder, dialog_choose_files) **plus M2 carry-over** (settings_get/set/list). NOTE: `vault_reindex` stays mocked (M7 deferral). + - Step 15.4: trim `apps/desktop-tauri/src/lib/ipc/mocks/vault.ts` to keep ONLY `vault_reindex` (M7 stub) and `vault_create` (M5 onboarding deferral). Delete every other vault route. Update `mocks/index.ts` if it imports deleted route names. + - Step 15.5: verify `apps/desktop-tauri/src/services/vault-service.ts` shape — `createInvokeForwarder('vault')` maps `getStatus` → `vault_get_status`. Plan's note: Rust impls match the existing renderer expectations, so no service-layer change should be required. If `pnpm test` flags shape diff, adjust the forwarder mapping. + - Step 15.6: create `apps/desktop-tauri/e2e/specs/m3-vault-smoke.spec.ts` per plan — two runtime tests: open vault + list notes + read+write Turkish-character roundtrip. Use `M3_TEST_VAULT_PATH` env (defaults to `~/memry-test-vault-m3`). + - Step 15.7: run full check matrix (lint/typecheck/test/bindings:check/capability:check/port:audit/command:parity/cargo:check/cargo:clippy/cargo:test). + - Step 15.8: update `apps/desktop-tauri/scripts/command-parity-audit.ts` ledger to classify `vault_reindex` as `deferred:M7` and `vault_create` as `mocked:M5`. + - Step 15.9: commit `m3(renderer): swap vault_*/shell_*/dialog_* to real Rust + runtime e2e smoke`. + +- **Task 16 — Bench, acceptance gate, PR**: + - Step 16.1: write `apps/desktop-tauri/src-tauri/tests/vault_bench.rs` per plan — 100-note vault scan, `<500ms` assertion, release-build required. Register `[[test]] name = "vault_bench" required-features = ["test-helpers"]`. + - Step 16.2: run bench in release mode: `cargo test --release --features test-helpers --test vault_bench -- --nocapture`. Local Apple-silicon target `<80ms`; acceptance gate `<500ms`. + - Step 16.3: full final acceptance gate verification — every command from plan Step 16.3 exits 0. Runs lint, typecheck, test, bindings:check, capability:check, port:audit, command:parity, cargo:check, cargo:clippy, cargo:test, plus a manual cold-start smoke against the dev runtime. + - Step 16.4: count Rust tests — expect ~79 (28 M2 + 9 paths + 9 fs + 9 frontmatter + 5 notes_io + 8 prefs + 6 registry + 4 watcher + 1 bench). + - Step 16.5: REMOVE the drag-drop spike telemetry from `apps/desktop-tauri/src/main.tsx` (the `void listen('vault-drag-drop', ...)` block added in Phase F Task 14.3). Commit `m3(spike): remove drag-drop spike telemetry; smoke documented in scripts/drag-drop-smoke.md`. + - Step 16.6: push branch + open PR. Title: `m3: Vault FS + file watcher`. Body per plan template (lines ~4533–4585) — Summary, Acceptance gate (10 checkboxes), Carry-forward ledger, Test plan, Risk coverage. + - Step 16.7: do NOT merge. User owns the merge decision (typically via `/land-and-deploy` gstack skill). + +### Methodology — verification + atomic commits + +1. **Invoke `superpowers:using-superpowers`** first. For Step 16.1 (bench), invoke `superpowers:test-driven-development` because the bench IS the test (RED-GREEN — write failing assertion, measure, prove green). For Task 16.6 (PR open), optionally invoke `superpowers:finishing-a-development-branch`. +2. **Three commits expected:** Task 15 = 1 commit, Task 16 bench = 1 commit, Task 16 spike-removal = 1 commit. PR open = no new commit. +3. For Task 15: + - Step 15.1: edit `generate_bindings.rs` — add `use memry_desktop_tauri_lib::vault;` to imports, then extend `collect_commands![...]` macro with 23 entries and `.typ::<...>()` chain with 13+ vault types. Plan's exact listing is your source of truth. + - Step 15.2: regen → `pnpm bindings:generate`. Inspect `apps/desktop-tauri/src/generated/bindings.ts` — every M3 type and command should appear. + - Step 15.3-15.4: edit `invoke.ts` (real-commands Set) and `mocks/vault.ts` (trim). + - Step 15.5: run `pnpm test` to verify service layer. + - Step 15.6: write the e2e spec. + - Step 15.7: run the full check matrix. Fix any failure before commit. + - Step 15.8: update parity ledger. + - Step 15.9: ONE atomic commit covering bindings + invoke.ts + mocks + service + e2e + parity-audit. The commit message hints at scope: "swap ... to real Rust + runtime e2e smoke". +4. For Task 16: + - Step 16.1-16.2: bench RED-GREEN. Write the test → run → assertion either passes or you have a real perf problem. Plan provides the exact 100-note seed loop. + - Step 16.3: final gate — every command must exit 0. ANY failure = stop, fix, re-run. + - Step 16.4: spot-check test counts. + - Step 16.5: remove spike telemetry from `main.tsx`. Commit. + - Step 16.6: push + PR. Use `gh pr create` with HEREDOC body. Do NOT merge. + +### Critical gotchas + +1. **`generate_bindings.rs` Specta type ordering:** Order matters for diff stability. Plan lists types alphabetically by module path: `db::*` first (carry-over from M2), then `vault::*`. Don't reorder; bindings.ts diff would be unnecessarily noisy. +2. **`bindings:check` is the post-regen guard:** It re-runs the generator and diffs against the committed `bindings.ts`. If the generator output differs (e.g., a Specta proc-macro changed a field name), `bindings:check` fails. The fix is `pnpm bindings:generate` again, then commit the regenerated file. +3. **`realCommands` Set ordering:** TypeScript Sets preserve insertion order. Plan's order matches the bindings file ordering — keep it for diff stability. The `realCommands` Set is consulted at runtime to decide whether to invoke the real backend or the mock. +4. **`vault_reindex` is NOT in `realCommands`:** It stays mocked because the Rust impl is just a stub returning `{ deferredUntil: 'M7' }`. If you accidentally add it to `realCommands`, the renderer's settings UI will see the stubbed payload instead of the mock's no-op success — both are fine in M3 but the parity ledger expects mocked. +5. **`vault_create` legacy mock:** The Rust side has no `vault_create` command. The renderer's onboarding flow uses `dialog_choose_folder` + `vault_open` directly. The `vault_create` mock route stays alive ONLY because the legacy onboarding component still references it; M5 removes the component during the notes-CRUD refactor. Phase G must NOT add a Rust `vault_create` — the parity ledger flags it as `mocked:M5`. +6. **`mocks/index.ts` imports may break after trimming:** When you delete `vault_open` etc. from `mocks/vault.ts`, the named export from `mocks/index.ts` (if it re-exports) loses those names. Run `pnpm typecheck` after trim — TypeScript will surface every dangling import. Fix them by removing the re-exports or routing through the now-trimmed module. +7. **Service forwarder shape match:** `vault-service.ts` uses `createInvokeForwarder('vault')` which builds command names from the method names (`getStatus` → `vault_get_status`). The Rust commands match — but the forwarder might pass args under different keys. Plan Step 15.5: don't preemptively change anything; run `pnpm test` and only adjust if a failure surfaces. +8. **`m3-vault-smoke.spec.ts` is runtime-lane:** It requires the Tauri dev runtime, not the M1 mock-lane Vite WebKit harness. Plan Step 15.6 says "If `playwright.config.ts` does not yet have a runtime-lane target, follow the comment in `e2e/playwright.config.ts` that documents the harness — for M3 it is acceptable to gate the suite behind `M3_TEST_VAULT_PATH` so CI does not run it without a vault checkout." Read the existing config; if there's no runtime lane, the M3 spec runs as a gated dev-only check. +9. **`M3_TEST_VAULT_PATH` env:** Defaults to `~/memry-test-vault-m3`. The README created this directory in pre-flight. The e2e spec uses `process.env.M3_TEST_VAULT_PATH ?? \`${process.env.HOME}/memry-test-vault-m3\`` so dev runs without env work. +10. **Bench must run with `--release`:** Plan's bench fails with `<500ms` assertion in debug mode (5–10× slower). The exact command: `cargo test --release --features test-helpers --test vault_bench -- --nocapture`. Don't run without `--release` and report flakes — that's a false failure. +11. **Bench seeding bottleneck:** The 100-note seed loop is sequential because `notes_io::write_note_to_disk` holds the path lock. On dev hardware this takes ~2s; on CI maybe 5s. The MEASUREMENT (`list_supported_files`) is what's bench'd, not the seed. Don't `tokio::join_all!` the seed — sequential is intentional for bench reproducibility. +12. **`port:audit` must stay clean:** No new `electron-log` imports, no `from 'electron'`, no `@electron`. Phase G's renderer changes (invoke.ts edits, mock trim, service tweak) shouldn't introduce any. `pnpm port:audit` exits 0 means clean. +13. **`command:parity` must classify all 25+ commands:** 3 settings (M2 real) + 15 vault (M3 real except 2 deferred) + 3 shell (M3 real) + 2 dialog (M3 real) + ~10 mocked-only feature domains from M1. Plan Step 15.8 adds two ledger entries. `pnpm command:parity` exits 0 with no unclassified renderer calls. +14. **PR title convention:** `m3: Vault FS + file watcher` — matches conventional commit style (`: `). The PR body uses HEREDOC for proper markdown formatting. +15. **PR test plan checklist:** Per repo's CLAUDE.md ship workflow, every PR needs a Test plan section with bulleted markdown checklist. Plan's body template (lines ~4566–4577) provides the exact wording — use it verbatim via HEREDOC. +16. **No merge, no force-push, no branch delete:** User's global CLAUDE.md forbids unprompted destructive ops. Push + open PR = done. Wait for user. Use `/land-and-deploy` (gstack skill) is the user's preferred merge path. +17. **Spike telemetry removal commit is small:** Step 16.5's commit touches only `main.tsx`. Don't bundle it with bench or PR-prep edits — atomic per change. + +### Constraints + +- **No new vault commands:** The 18-command surface is locked from Phase E. Don't add `vault_init` or similar in Phase G. +- **No mock additions:** Mock surface SHRINKS in Phase G (trim `mocks/vault.ts`). Don't add new routes. +- **No new tests beyond `vault_bench.rs`:** The 78 vault tests + 1 bench = 79. Don't add unit tests for the bench code itself. +- **No service-layer refactor:** Keep `vault-service.ts` minimal — it's a thin forwarder. M5 will refactor the service layer when notes CRUD lands. +- **No PR merge:** Open the PR. Wait for user review. +- **No CI-config changes:** The runtime e2e lane is gated by env var; CI without the vault checkout is unaffected. +- **No CSP loosening:** The CSP from Phase F stays as-is. Don't add hosts to fix the e2e spec — the spec runs against the dev runtime, not a remote URL. + +### Acceptance criteria (Phase G done when all pass) + +```bash +cd /Users/h4yfans/sideproject/memry-worktrees/spike-tauri-m3 + +# Bindings regenerated +grep -q 'vault_open' apps/desktop-tauri/src/generated/bindings.ts +grep -q 'NoteFrontmatter' apps/desktop-tauri/src/generated/bindings.ts +grep -q 'VaultStatus' apps/desktop-tauri/src/generated/bindings.ts +grep -q 'VaultEvent' apps/desktop-tauri/src/generated/bindings.ts + +# Real commands set updated +grep -q "'vault_open'" apps/desktop-tauri/src/lib/ipc/invoke.ts +grep -q "'vault_list_notes'" apps/desktop-tauri/src/lib/ipc/invoke.ts +grep -q "'shell_open_url'" apps/desktop-tauri/src/lib/ipc/invoke.ts +grep -q "'dialog_choose_folder'" apps/desktop-tauri/src/lib/ipc/invoke.ts + +# vault_reindex stays mocked +! grep -q "'vault_reindex'" apps/desktop-tauri/src/lib/ipc/invoke.ts +grep -q 'vault_reindex' apps/desktop-tauri/src/lib/ipc/mocks/vault.ts + +# vault_create stays mocked +! grep -q "'vault_create'" apps/desktop-tauri/src/lib/ipc/invoke.ts +grep -q 'vault_create' apps/desktop-tauri/src/lib/ipc/mocks/vault.ts + +# Mock vault.ts trimmed (M3 routes deleted) +! grep -q "vault_open: async" apps/desktop-tauri/src/lib/ipc/mocks/vault.ts +! grep -q "vault_list_notes: async" apps/desktop-tauri/src/lib/ipc/mocks/vault.ts + +# E2E spec exists +test -f apps/desktop-tauri/e2e/specs/m3-vault-smoke.spec.ts +grep -q 'M3_TEST_VAULT_PATH' apps/desktop-tauri/e2e/specs/m3-vault-smoke.spec.ts + +# Bench exists + passes in release +test -f apps/desktop-tauri/src-tauri/tests/vault_bench.rs +grep -q 'name = "vault_bench"' apps/desktop-tauri/src-tauri/Cargo.toml +cd apps/desktop-tauri/src-tauri && cargo test --release --features test-helpers --test vault_bench 2>&1 | tail -3 +# expect: passes (under 500ms) + +# Spike telemetry REMOVED +cd /Users/h4yfans/sideproject/memry-worktrees/spike-tauri-m3 +! grep -q 'drag-drop spike' apps/desktop-tauri/src/main.tsx +! grep -q "listen\\('vault-drag-drop'" apps/desktop-tauri/src/main.tsx + +# Parity audit ledger updated +grep -q "vault_reindex" apps/desktop-tauri/scripts/command-parity-audit.ts +grep -q "vault_create" apps/desktop-tauri/scripts/command-parity-audit.ts +grep -q "deferred" apps/desktop-tauri/scripts/command-parity-audit.ts +grep -q "M7" apps/desktop-tauri/scripts/command-parity-audit.ts +grep -q "M5" apps/desktop-tauri/scripts/command-parity-audit.ts + +# Full final gate +pnpm --filter @memry/desktop-tauri lint +pnpm --filter @memry/desktop-tauri typecheck +pnpm --filter @memry/desktop-tauri test +pnpm --filter @memry/desktop-tauri bindings:check +pnpm --filter @memry/desktop-tauri capability:check +pnpm --filter @memry/desktop-tauri port:audit +pnpm --filter @memry/desktop-tauri command:parity +pnpm --filter @memry/desktop-tauri cargo:check +pnpm --filter @memry/desktop-tauri cargo:clippy +cd apps/desktop-tauri/src-tauri && cargo test --features test-helpers 2>&1 | tail -3 +# expect: ~79 passed (78 prior + 1 bench) +cd apps/desktop-tauri/src-tauri && cargo test --release --features test-helpers --test vault_bench 2>&1 | tail -3 +# expect: 1 passed (bench under 500ms) + +# Commits in Phase G +cd /Users/h4yfans/sideproject/memry-worktrees/spike-tauri-m3 +git log --oneline | grep -cE 'm3\((renderer|bench|spike)\)' # expect ≥ 3 (renderer + bench + spike-removal) + +# Branch pushed +git ls-remote --heads origin m3/vault-fs-and-watcher | grep -q m3/vault-fs-and-watcher + +# PR open +gh pr view m3/vault-fs-and-watcher --json number,title,state 2>/dev/null +# Expect: state OPEN, title "m3: Vault FS + file watcher" + +# Electron / packages / specs / plans untouched +git diff --name-only main..HEAD -- apps/desktop/ apps/sync-server/ packages/ docs/superpowers/specs/ docs/superpowers/plans/ | wc -l +# expect 0 +``` + +### When done + +Report to user: + +``` +Phase G complete — M3 shipped. +Tasks covered: 15, 16 +Commits (Phase G): 3 (..) +Commits (M3 total): +Rust tests: ~79 passed (78 vault + 1 bench) +TS tests: passed +Bench: 100-note vault scan ms (acceptance gate <500ms; local Apple-silicon target <80ms) + +Renderer integration: + - 22 commands swapped from mock to real Rust + - vault_reindex deferred (M7) — mocked path returns { deferredUntil: 'M7' } + - vault_create deferred (M5) — legacy onboarding helper retained + - Bindings regenerated with 13+ M3 types + - Runtime e2e smoke (m3-vault-smoke.spec.ts) — open + list + Turkish-roundtrip + +Manual smoke history: + - memry-file:// real image: 🟢 (Phase F) + - memry-file:// 1×1 PNG fallback: 🟢 + - memry-file:// 403 outside vault: 🟢 + - drag-drop real paths: 🟢 (or 🔴 fallback documented) + +Cleanup: + - Drag-drop spike telemetry removed from main.tsx + - scripts/drag-drop-smoke.md documents the smoke history + +Branch: m3/vault-fs-and-watcher pushed to origin +PR: — + +M3 milestone: ready for user review and merge. +Next: M4 plan authoring — invoke superpowers:writing-plans with spec §M4 (Crypto + Keychain + Auth). + +Blockers: +``` + +If acceptance fails at any check: + +1. Do not push a broken branch. +2. Diagnose: + - **`bindings:check` fails** → `pnpm bindings:generate` then commit the result. + - **`port:audit` fails** → grep for the violating import; remove or replace. + - **`command:parity` fails with "unclassified renderer call"** → either add the command to a parity ledger entry or remove the renderer call. + - **`cargo test --release --test vault_bench` exceeds 500ms** → check `--release` flag was set. Profile with `cargo flamegraph`. The most likely cause is the `dunce::canonicalize` re-run inside `list_supported_files` — Plan's impl canonicalizes once at entry. Don't optimize away the canonicalize without re-checking the path-safety contract. + - **e2e spec hangs** → Tauri dev runtime not up; check `playwright.config.ts` for the launch command. The runtime lane needs `tauri dev` running. +3. Report finding + fix plan, wait for approval before pushing PR. + +If still blocked: invoke `superpowers:systematic-debugging` and `superpowers:finishing-a-development-branch`. Report + wait for approval. + +### Ready + +1. Invoke `superpowers:using-superpowers`. Optionally `superpowers:test-driven-development` for the bench, `superpowers:finishing-a-development-branch` when reaching Step 16.6. +2. Read plan Tasks 15, 16 fully (lines ~4112–4630 of the plan file). +3. Run prerequisite verification. Report results. +4. Task 15: + - Extend `generate_bindings.rs` (commands + types). + - `pnpm bindings:generate && pnpm bindings:check`. + - Update `realCommands` in `invoke.ts`. + - Trim `mocks/vault.ts` (keep `vault_reindex` + `vault_create` only). + - Verify `vault-service.ts` shape (test if needed). + - Write `e2e/specs/m3-vault-smoke.spec.ts`. + - Update `scripts/command-parity-audit.ts` ledger. + - Run full check matrix (lint/typecheck/test/bindings:check/capability:check/port:audit/command:parity/cargo:check/cargo:clippy/cargo:test). + - Commit `m3(renderer): swap vault_*/shell_*/dialog_* to real Rust + runtime e2e smoke`. +5. Task 16: + - Write `tests/vault_bench.rs` (100-note scan with `<500ms` assertion). + - Run `cargo test --release --features test-helpers --test vault_bench` → green. + - Commit `m3(bench): 100-note vault scan <500ms acceptance test`. + - Run final acceptance gate matrix. Manual cold-start smoke. + - Remove spike telemetry from `main.tsx`. Commit `m3(spike): remove drag-drop spike telemetry; smoke documented in scripts/drag-drop-smoke.md`. + - `git push -u origin m3/vault-fs-and-watcher`. + - `gh pr create --title 'm3: Vault FS + file watcher'` with body per plan template. + - DO NOT MERGE. Report PR URL to user. + +## PROMPT END