CedroDB 0.8.0: command-line interface

CedroDB 0.8.0 adds an installable Python CLI, available as cedrodb and python -m cedrodb.

Commands cover database initialization, documents, atomic batches, queries, search, profiling, collection inventory, diagnostics, verification, backups, restore and changes. The CLI supports strict JSON input from arguments/files/stdin, structured output, documented exit codes and explicit database selection through --db or CEDRODB_PATH.

Install with python -m pip install cedrodb==0.8.0, then run cedrodb --help.

The npm SDK is version-aligned at 0.8.0; the new CLI belongs to the Python package.

Validation: Rust checks on Linux/macOS/Windows, native SDK builds on Linux, Windows and both macOS architectures, 80 Python SDK/CLI tests, interoperability checks and an isolated source-distribution build/install test.

Experimental release. See CLI documentation for command semantics and recovery limits.

CedroDB 0.7.0: diagnostics and performance tools

CedroDB 0.7 helps applications inspect local database work: see collection/index inventory, inspect session counters, and execute queries or hybrid retrieval with their actual plans and native timings.

• Database.diagnostics() reports content limits, collection/index counts, handle health, and bounded query/search/shared-commit counters without document values.
• Rust profile_query / profile_search, Node profileQuery / profileSearch, and Python profile_query / profile_search execute once and return the ordinary page plus native elapsed microseconds and actual candidate/scanned/returned counts.
• Python includes python -m cedrodb doctor and an isolated synthetic benchmark command. The benchmark checks result equality, measures scan/index variants, records empirical latency summaries, batch writes, index construction and reopening, and opens no application database.
• Native SDK examples demonstrate inspection, periodic application-managed logging and index comparisons. Installation documentation explains OS/CPU/libc requirements, virtual environments and native verification.
• Added a CI gate that rebuilds and tests the standalone Python source archive, including CLI subprocesses using the isolated rebuilt wheel.

The transaction log and backup formats are unchanged. Session metrics reset on reopen; they do not track every public API or external model/tool call. Commit counters include nonempty shared-commit attempts and exclude earlier validation failures/conflicts/no-ops. Timers add overhead; counters do not provide histograms or process RSS. Profiling executes actual work and may traverse additional candidates to count a keyset range.

Validation: 113 Rust, 70 Node and 70 Python tests, native Node/Python interoperability, strict TypeScript fixtures, and the release CI across Linux, macOS ARM64/Intel and Windows. Binaries and source archives are copied from the successful CI artifact; checksums accompany each archive.

This remains an experimental 0.x release. The exact retrieval engine scans RAM-resident records; these tools do not establish production readiness, model quality or superiority over other databases.

Installation · Performance contracts · Benchmark methodology · Portfolio

CedroDB 0.6.0 — agent checkpoints and hybrid memory

CedroDB 0.6 adds local memory retrieval and revision-protected checkpoints for application-managed AI agents. Save a checkpoint and ordinary result/outbox documents in one durable transaction, then reopen the same thread after restart. A stale continuation receives a conflict and writes nothing.

• Search JSON memory by text/BM25, supplied vectors/exact cosine, or hybrid/RRF. Metadata prefilters run before scoring; equality indexes narrow candidates; scan-budget exhaustion is an explicit error.
• Use matching native Rust, Node.js/TypeScript and Python APIs with typed results, deterministic ranking ties and separate scoring details.
• Preserve exact floating-point values during replay and restore, fixing possible one-ULP changes in earlier releases.
• Run the pinned PydanticAI 2.56.0 conversation example with TestModel: conversation identity, messages and usage survive reopening, with no model-service calls.
• Explore the recorded Rust agent demo and eight Node/Python recipes on the portfolio.

Validation: 104 Rust, 62 Node and 66 Python tests locally; native SDK builds, interoperability, optional PydanticAI recipe and source distributions are checked in the release CI. SHA-256 sidecars accompany each distribution.

The existing log and backup formats are unchanged. _cedro.agents.* is newly reserved; migrate conflicting ordinary collections with 0.5 before upgrading. This release remains experimental. Retrieval scans committed in-memory documents; no ANN index, model inference, framework checkpointer protocol, tool authorization or automatic workflow resumption is provided.

Agent contracts · Research and positioning · Migration notes

CedroDB 0.5.0 — Persistent jobs and fenced atomic results

CedroDB 0.5.0 brings persistent local jobs to the same Rust database used for documents, guarded inventory changes, outbox events and backups.

• Stable job IDs deduplicate insertion, including completed/dead jobs.
• Delayed availability, priorities and deterministic claim ordering.
• Durable leases, renewed expiration and stale/expired token rejection.
• Retry delays, bounded attempts, expired-job recovery and explicit dead-job redrive.
• An acknowledgement can atomically complete the job and save generated business documents/outbox events in one transaction.
• Shared safe-number job payloads across Rust, Node.js and Python; typed Job/LeasedJob APIs.
• Reserved internal mutation namespaces, strict queue record validation and atomic capacity failures without consuming an attempt.
• Executable worker recipes, real recorded recovery/inventory/queue scenarios, updated package READMEs and a gated roadmap toward 1.0.

Validation: 75 Rust tests, 43 Node tests and 49 Python tests (167 total), four native build targets, numeric/storage interoperability, standalone Python source rebuilds, strict TypeScript declarations and independent atomicity/fencing/backup review. The exact six public SDK recipes also execute successfully. Release artifacts retain their CI SHA-256 hashes.

Experimental pre-1.0. One handle/process owns the database; data stays in RAM and queue scans are O(n). Completed/dead jobs and history have no automatic retention. Applications own workers, clocks, periodic expired-job recovery and external-effect idempotency. Tokens fence one history, not diverged restored copies. Leave headroom for lease/error metadata; capacity errors roll back the transition. No production readiness or performance superiority claim is made.

Migration: log and backup formats are unchanged. _cedro.jobs. becomes a reserved prefix for generic writes; migrate ordinary collections using that prefix with 0.4 before upgrading. See docs/jobs.md, docs/migrations.md and docs/roadmap.md.

CedroDB 0.4.0 — Guarded inventory and outbox transactions

CedroDB 0.4.0 adds guarded multi-document writes for inventory reservations and idempotent local requests.

• Check absent/equals conditions against committed state before writing a batch.
• Update stock, create an order and write its outbox event in one atomic transaction.
• Reject stale reads and duplicate request keys without writing or advancing the cursor.
• Return the first failed condition and the latest durable cursor in typed Rust/Node/Python APIs.
• Keep null and missing keys distinct, and retain structural numeric equality across languages.
• Validate input/frame limits before duplicating operation payloads.

Validation: 59 Rust tests, 25 Node tests and 36 Python tests; CI builds and interoperability pass on all four native platforms. Tests include competing stock reservations, atomic failure, limits, indexes, reopen and backup compatibility.

Experimental. Guard every document your decision depends on; this is not MVCC or a snapshot across earlier reads. Applications own business validation, revisions for ABA detection and external-event deduplication. The transaction log format and 0.3 backup APIs are unchanged.

CedroDB 0.3.0 — Verified backups and offline recovery

CedroDB 0.3.0 adds operational recovery for offline applications and desktop upgrades.

• Verify the complete transaction log without repairing or rewriting it.
• Create consistent versioned backup files with full expected length and CRC32.
• Validate a backup before restoring into a new directory; existing data is never overwritten.
• Preserve transaction history and change cursors across restoration.
• Use typed Rust, Node.js and Python APIs, executable offline examples and expanded recovery/migration documentation.

Validation: 49 Rust tests, 18 Node tests and 25 Python tests; native packages and interoperability verified on macOS ARM64/Intel, Linux x64 and Windows x64. CI artifacts are published unchanged with SHA-256 sidecars.

Experimental release. Live documents remain in RAM; verification needs additional replay memory and holds the engine mutex. Backups retain the full growing log. CRC32 is not authentication. There is no production certification, compaction or multi-process access. Transaction log format remains compatible with 0.2; backup containers use a separate format.

CedroDB 0.2.0 — Native Node.js and Python libraries

CedroDB 0.2 adds local automation primitives and native libraries for Node.js and Python.

• Durable changefeed with transaction cursors and encoded page budgets.
• Atomic compare-and-exchange, cross-collection batches and outbox building blocks.
• JSON Pointer filters, keyset pagination and session equality indexes.
• Native Node-API package with ESM, CommonJS and TypeScript types.
• Native PyO3/ABI3 package for Python 3.9+, including a standalone source distribution.

Validation: 40 Rust tests, 12 Node tests, 17 Python tests and sequential Python/Node interoperability checks. CI builds and tests GNU/Linux x64 (Ubuntu 22.04), Windows x64, macOS ARM64 and macOS Intel.

Node.js 18+ and Python 3.9+ are supported. Source builds require Rust and a native linker; use a compatible prebuilt/wheel to avoid compiling.

Experimental: live data/indexes reside in memory, one database handle/process opens storage at a time, indexes are recreated after reopening, and pagination is not a snapshot. External effects require application-managed checkpoints and idempotency. SQL, MVCC, replication and log compaction are not included.

Package files and SHA-256 checksums are attached. See the repository for API documentation and the portfolio for executable installation commands and recorded Rust outputs.