msnav 0.2.0 → 0.3.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 3ea0f1f4fee68dd182f4e86da45adb998043e96a62d79effa4a05094ab8fdbed
-  data.tar.gz: 75cd16332b3edc2b185adcbd155dcc4fc88e3904a5887065d3d910edaaccea64
+  metadata.gz: c6d6d26b0049b7aa5df6c60df61e989ebd2402db9912cfb97ab30f176b6eacd6
+  data.tar.gz: 84ba3e939ece29c631b8fd17649888a6f4ef6a7ee1fa4be29d971a497682e40d
 SHA512:
-  metadata.gz: 87694f9c0587ea8bea74c54027101d26f90c7c42e06790e853388a8608562a1dfadee1736d15fb272aa0f8f86fead6e45afc6684825d47fca1912b3f5c255c9d
-  data.tar.gz: 9f1c22c8076ccf207e700b9378ebeb97ee2f4d6c1e6fccde3c6d2f37b23f670edf8aa3164a8c48d038a8f7f5c0629e7d37f0c5cea097956712416cbfb1ad13dd
+  metadata.gz: 594621248be0da1c37217e7286b08480dd7f9f76d48f2ad767fa1641c428867a9fa5ea4344f2b57dc0f1cae2f130fc9814563204645b0ed702d7923b5abc27ff
+  data.tar.gz: a71963f36a2aece2d7e7f4322f2a207c1e1a1efea2f1d4e366ec0d19b37a72e4739a1eaee592896812102b455e96d0f4826caca4584c9f7539a5c4ac864eb7f7

data/README.md

@@ -110,13 +110,19 @@ nothing (msnav never indexes).
 
 ## Compatibility
 
-- Reads coderag **schema v4** DBs (errors on older; warns-and-continues on
-  newer). Writes only the two v4 message-bus tables (`windows`,
-  `window_commands`) every daemon on the hub shares.
+- Opens `coderag.db` **strictly read-only**. Compatibility is checked via
+  the index's `read_contract` meta key (accepts 1.x) when present; older
+  indexes are accepted from schema v4 up.
+- The editor-window registry and open-command queue are **msnav-owned**
+  (coderag dropped this responsibility entirely): a sidecar
+  `msnav-windows.db` next to the index in the hub's storage dir, shared
+  through the same bind mount, so cross-container open-routing between msnav
+  daemons keeps working. msnav versions it itself (`PRAGMA user_version`).
+  It is ephemeral liveness state; deleting it is safe.
 - Ruby ≥ 2.6; gems: `sqlite3`, `webrick`.
 - The Docker-Desktop caveat from coderag applies here too: SQLite (WAL) over
   bind mounts with several concurrent writers is the sensitive spot; msnav
-  keeps its writes tiny (window registry only).
+  writes only to its small sidecar, never to the index.
 
 ## Troubleshooting
 

data/lib/msnav/server.rb

@@ -11,7 +11,8 @@ module Msnav
   # host-side `coderag index` or a peer daemon's rebuild hot-reloads every
   # msnav on the hub within a second, requests always see a consistent index.
   class Holder
-    attr_reader :cfg, :store, :windows, :service_root, :service_name
+    attr_reader :cfg, :store, :windows, :windows_store, :service_root,
+                :service_name
 
     def initialize(cfg, service_root: nil, service_name: nil)
       @cfg = cfg
@@ -21,7 +22,12 @@ module Msnav
       @service_root = service_root
       @service_name = service_name
       @store = Store.new(cfg.db_path)
-      @windows = WindowRegistry.new(@store)
+      # coderag no longer carries window state at all — the registry is
+      # msnav-owned, in a sidecar DB inside the same shared storage dir, so
+      # every msnav daemon on the hub (one per container) routes opens
+      # through the mount exactly like before
+      @windows_store = WindowsStore.new(cfg.storage_dir + "msnav-windows.db")
+      @windows = WindowRegistry.new(@windows_store)
       @mutex = Mutex.new
       @generation = 0
       @db_generation = @store.index_generation

data/lib/msnav/store.rb

@@ -4,17 +4,18 @@ require "pathname"
 require "sqlite3"
 
 module Msnav
-  # Access to the shared coderag SQLite index.
+  # Read-only access to the shared coderag SQLite index.
   #
-  # coderag (Python) owns the schema and the writes that matter (graph, facts,
-  # chunks); msnav writes only the two v4 message-bus tables (`windows`,
-  # `window_commands`) that every daemon on the hub shares. One connection
-  # guarded by a Mutex: navigation itself runs on the in-memory graph, so the
-  # DB sees only window-registry traffic, generation polls, and graph reloads
-  # — serializing those is simpler than per-thread connections and equally
-  # correct across WEBrick's request threads.
+  # coderag (Python) owns the index; since its schema v5 the DB is a pure
+  # reader contract (meta key `read_contract`, currently 1.x) and holds no
+  # mutable daemon state — msnav therefore opens it strictly read-only and
+  # never writes to it. The window registry lives elsewhere (WindowsStore).
+  #
+  # One connection guarded by a Mutex: navigation runs on the in-memory
+  # graph, so the DB sees only generation polls and graph reloads.
   class Store
-    SCHEMA_VERSION = 4 # the version msnav is written against
+    SCHEMA_VERSION = 4      # oldest index schema msnav understands
+    READ_CONTRACT_MAJOR = 1 # newest reader contract msnav is written against
 
     attr_reader :path
 
@@ -62,36 +63,104 @@ module Msnav
       end
     end
 
+    def has_table?(name)
+      with_conn do |db|
+        !db.get_first_row(
+          "SELECT 1 FROM sqlite_master WHERE type='table' AND name = ?",
+          [name]).nil?
+      end
+    end
+
     private
 
     def connect
-      db = SQLite3::Database.new(@path.to_s)
+      db = SQLite3::Database.new(@path.to_s, readonly: true)
       db.busy_timeout = 5000
-      db.execute("PRAGMA foreign_keys=ON")
       db
     rescue SQLite3::Exception => e
       raise IndexStaleError, "#{@path} could not be opened (#{e.message})"
     end
 
+    # Compatibility gate. Newer coderag publishes `read_contract` (the
+    # reader-facing surface version) — that is the authoritative check.
+    # Older indexes are accepted from schema v4 up.
     def check_version
-      row = begin
-        @conn.get_first_row("SELECT value FROM meta WHERE key='schema_version'")
+      contract = begin
+        get_meta("read_contract")
       rescue SQLite3::Exception => e
         raise IndexStaleError,
               "#{@path} is not a coderag database (#{e.message}) — " \
               "delete it and run `coderag index` on the host"
       end
-      version = row ? row[0].to_i : 0
+      if contract
+        major = contract.split(".").first.to_i
+        return if major == READ_CONTRACT_MAJOR
+        raise IndexStaleError,
+              "#{@path} publishes read contract #{contract}, msnav is written " \
+              "against #{READ_CONTRACT_MAJOR}.x — upgrade msnav"
+      end
+      version = (get_meta("schema_version") || 0).to_i
       if version < SCHEMA_VERSION
         raise IndexStaleError,
-              "#{@path} is schema v#{version}, msnav needs v#{SCHEMA_VERSION} — " \
+              "#{@path} is schema v#{version}, msnav needs v#{SCHEMA_VERSION}+ — " \
               "run `coderag index` on the host to migrate"
       end
       return if version == SCHEMA_VERSION
-      # a newer coderag may have added tables msnav doesn't know; the v4
-      # tables it reads are append-only by convention, so proceed loudly
-      warn "msnav: #{@path} is schema v#{version} (msnav is written against " \
-           "v#{SCHEMA_VERSION}) — continuing, but upgrade msnav if navigation misbehaves"
+      warn "msnav: #{@path} is schema v#{version} without a read_contract " \
+           "(msnav is written against v#{SCHEMA_VERSION}) — continuing, " \
+           "but upgrade msnav if navigation misbehaves"
+    end
+  end
+
+  # Writable sidecar for msnav's own mutable state: the editor-window
+  # registry and open-command queue. coderag dropped this responsibility
+  # entirely (its index is a read-only contract now), so msnav owns the
+  # storage — and versions it itself via PRAGMA user_version. Lives next to
+  # the index in the hub's storage dir, shared through the same bind mount,
+  # so every msnav daemon on the hub sees the same windows. Created on
+  # demand; safe to delete (ephemeral liveness state).
+  class WindowsStore
+    USER_VERSION = 1
+
+    DDL = [
+      "CREATE TABLE IF NOT EXISTS windows (" \
+      "window_id TEXT PRIMARY KEY, authority TEXT NOT NULL DEFAULT ''," \
+      "roots TEXT NOT NULL, path_mappings TEXT NOT NULL," \
+      "host_roots TEXT NOT NULL, seq INTEGER NOT NULL, last_poll REAL NOT NULL)",
+      "CREATE TABLE IF NOT EXISTS window_commands (" \
+      "id INTEGER PRIMARY KEY AUTOINCREMENT, window_id TEXT NOT NULL," \
+      "payload TEXT NOT NULL, created_at REAL NOT NULL)",
+      "CREATE INDEX IF NOT EXISTS idx_window_commands_window " \
+      "ON window_commands(window_id)",
+    ].freeze
+
+    attr_reader :path
+
+    def initialize(path)
+      @path = Pathname.new(path.to_s)
+      @path.parent.mkpath
+      @mutex = Mutex.new
+      @conn = SQLite3::Database.new(@path.to_s)
+      @conn.busy_timeout = 5000
+      @conn.execute("PRAGMA journal_mode=WAL")
+      version = @conn.get_first_value("PRAGMA user_version").to_i
+      if version > USER_VERSION
+        raise IndexStaleError,
+              "#{@path} was created by a newer msnav (registry v#{version}, " \
+              "this msnav understands v#{USER_VERSION}) — upgrade msnav"
+      end
+      DDL.each { |stmt| @conn.execute(stmt) }
+      @conn.execute("PRAGMA user_version = #{USER_VERSION}") if version.zero?
+    end
+
+    def with_conn
+      @mutex.synchronize { yield @conn }
+    end
+
+    def close
+      @mutex.synchronize do
+        @conn.close unless @conn.closed?
+      end
     end
   end
 end

data/lib/msnav/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module Msnav
-  VERSION = "0.2.0"
+  VERSION = "0.3.0"
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: msnav
 version: !ruby/object:Gem::Version
-  version: 0.2.0
+  version: 0.3.0
 platform: ruby
 authors:
 - Yaroslav Zahoruiko
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2026-07-05 00:00:00.000000000 Z
+date: 2026-07-06 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: sqlite3