4 Commits

Include renames

Author	SHA1	Message	Date
bvandeusen	1aca294b95	Bump to 0.2.0 — a release at 0.1.0 would have been a downgrade ... Found while preparing the release, and it would have quietly defeated the point of cutting one. The version does NOT come from the tag. `desktop/packaging/build-version.sh` reads `desktop/src-tauri/Cargo.toml`, and on `dev` it appends the CI run number (`0.1.269`) while on a tag or `main` it ships the file's value verbatim — which was still `0.1.0`. So tagging today would have published a "release" numbered BELOW every dev build already out there, and below the 0.1.227 on the operator's phone. The desktop updater compares semver: an installed build would have read the stable manifest, seen a version older than its own, and correctly concluded it was already current. The APK would have installed (versionCode is the run number and keeps rising) while displaying a version that reads as going backwards. build-version.sh predicted this in its own comment: "Bumping the minor in Cargo.toml still wins over any dev build on the old line, which is the ordering you want: 0.2.0 > 0.1.2932." Bumped in four places, which is every one that can be read by something: - `desktop/src-tauri/Cargo.toml` — the actual source; everything else derives - `tauri.conf.json` — overridden at build time by `--config`, but a checked-in value that lies is exactly how issue 2183 happened - `pyproject.toml` + `__init__.py` — the server's APP_VERSION fallback when no BUILD_VERSION is injected `core` and `android/ffi` stay at 0.1.0 deliberately: internal library crates whose version reaches no surface, and versioning workspace libs independently of the app is normal. Cargo.lock regenerated with `cargo fetch` per ci-requirements — one line, the version itself. Verified: a tag build now yields 0.2.0 and a dev build 0.2.270, so stable is an upgrade for every existing install and dev stays ahead of stable.	2026-08-23 14:02:02 -04:00
bvandeusenandClaude Opus 5	5d0de7a682	android: the binding generator gets its own crate, free of the app's deps ... Third Android run got further than either before it — all four ABIs cross-compiled, vendored OpenSSL and all — then the generator died: error: failed to run custom build command for `openssl-sys v0.9.117` That is the HOST build. The generator was a [[bin]] inside thoughtsync-ffi, so building it compiled that crate and therefore the core, reqwest, native-tls and openssl-sys for linux. The vendored-OpenSSL block is scoped to `cfg(target_os = "android")`, so the host build went looking for a system OpenSSL that ci-rust-android has no reason to carry. Adding libssl-dev to the image would have fixed it and been wrong: a code generator has no business linking the app's TLS stack to emit Kotlin. Splitting it into thoughtsync-uniffi-bindgen, whose only dependency is uniffi, removes the entire chain. Verified from the dependency graph rather than from a build that happened to succeed — `cargo tree -p thoughtsync-uniffi-bindgen` contains none of openssl-sys, native-tls, reqwest, thoughtsync-core or rusqlite. It stays a WORKSPACE MEMBER on purpose. Sharing one lockfile is what keeps uniffi here and uniffi linked into the .so at one version; they are two halves of one ABI, and a separate lockfile is precisely how they would drift apart. The cost is that the desktop lane now compiles ~15 generator crates it never runs — cheap next to Tauri, and better than leaving the crate unlinted. Drops the `bindgen` feature and required-features bin from thoughtsync-ffi, which existed only to keep those crates off the desktop lane and now have nothing to gate. Local fmt + clippy + test all green before pushing (107 tests). Co-Authored-By: Claude Opus 5 (1M context) <noreply@anthropic.com>	2026-08-18 15:54:10 -04:00
bvandeusenandClaude Opus 5	f90b9203a7	android: bind the core to Kotlin through uniffi (M12 step 4) ... `android/ffi` is to Android what `desktop/src-tauri/src/commands/` is to the desktop: a shim over the shared core holding no logic of its own. Third workspace member, so the desktop lane's `cargo clippy --all-targets` compiles and lints it — which until the Android lane lands (step 5) is the only thing that does. Three decisions worth stating. MIRRORED RECORDS, NOT DERIVES ON THE CORE. The core's model structs are serde shapes contracted with the shared Vue frontend, and one of them holds a serde_json::Value, which has no uniffi representation. Hanging uniffi derives on them would couple two unrelated consumers to one definition. The cost of mirroring is drift — an Android client quietly missing a field the desktop gained — so every conversion destructures the core struct exhaustively. Add a field to core::local::models::Note and this crate stops compiling until Android is told what to do with it. NoteEdit IS A LIST, NOT A STRUCT OF NULLABLE FIELDS. The store's patch format distinguishes three states: leave alone, set, and clear to null. Kotlin cannot express the third with a nullable field — `title = null` in a data class is indistinguishable from `title` unset — so the editor could never clear a title. Explicit Clear* variants say it out loud and give Kotlin a sealed class. ASYNC IS TOKIO-BACKED, AND CANCELLATION ALREADY WORKED. Exported async methods become Kotlin suspend functions. When a coroutine is cancelled uniffi drops the future, and no async path in the core holds the store lock across an await — a std MutexGuard isn't Send, so the compiler has been enforcing that all along. A cancelled sync leaves the store consistent and simply hasn't stamped last_sync_at, which is only written after both halves of a cycle succeed. Also here: * core gains Db::conn(). Every consumer was writing `db.0.lock().map_err(|e| e.to_string())?` by hand, and worse, any helper returning the guard had to NAME rusqlite::Connection — which would have made rusqlite a dependency of a layer whose whole point is not knowing what the store is made of. Same trap as the update.rs test module in step 1. * The uniffi `cli` feature is gated behind our own `bindgen` feature. It drags in clap, askama and goblin for a three-line binary, and the desktop lane should not compile a code generator it never runs. * The bindgen binary lives in this workspace on purpose: generated bindings and the linked uniffi runtime are two halves of one ABI, and compiling the generator against the same dependency keeps them in step by construction. That is why ci-rust-android ships no uniffi-bindgen. Tests cover the round trip the Android skeleton needs (open a store in a directory that does not exist yet, write a note, read it back), that a body-only note still has a display_title, that set and clear are genuinely different edits, and that an unlinked app reports NotLinked rather than an error. Known and deliberate: the workspace sets panic = "abort", so a panic crossing the FFI aborts instead of arriving in Kotlin as an exception. Same behaviour the desktop already has; noted in the crate header rather than silently changed. Scribe #2733. Co-Authored-By: Claude Opus 5 (1M context) <noreply@anthropic.com>	2026-08-18 11:09:52 -04:00
bvandeusenandClaude Opus 5	0a7480cf9b	core: extract the store and sync engine into a shared crate (M12 step 1) ... Android becomes a native Kotlin client over this same code (Scribe note 2730), so the local store and sync engine stop being modules of the desktop app and become `thoughtsync-core`, a crate with no UI framework in it at all. This is a move, not a rewrite, and the measurement is why: every file in local/ and sync/ already carried ZERO Tauri references — 4,980 of 6,372 lines. The coupling was 473 lines of command shim, which stays behind in the desktop crate as src/commands/. Kept as git renames so history follows the files. The desktop imports them under their old names (`use thoughtsync_core::{local, sync}`) so every call site reads exactly as before. What moved is where they live, not what they are. Two things a workspace changes that are easy to miss, both caught before pushing: [profile.release] now lives at the workspace ROOT. Cargo silently ignores profiles declared by a non-root member — leaving it in the desktop crate would have dropped lto/strip/opt-level from every release build with only a warning. And a workspace shares ONE target dir, so the bundles moved from desktop/src-tauri/target to target/. Thirteen references across publish-release, debundle-graphics, verify.sh, package-prebuilt and the workflow now point there. Pinning target-dir back would have been the smaller diff, but the Android lane also produces Rust artifacts and they do not belong under desktop/. Also retires the Tauri Android lane in the same push rather than leaving a path that is being replaced: gen/android, android.yml and docs/android-dev.md are gone, the mobile_entry_point attribute with them, and the lib drops to rlib — staticlib/cdylib existed for Tauri mobile, and the .so Android loads will be built from the core crate instead. Rule 22, no parallel path. Co-Authored-By: Claude Opus 5 (1M context) <noreply@anthropic.com>	2026-08-17 23:12:26 -04:00