msnav 0.2.0

data/lib/msnav/config.rb

@@ -0,0 +1,79 @@
+# frozen_string_literal: true
+
+require "pathname"
+require "yaml"
+
+module Msnav
+  # The slice of coderag.yml msnav needs: where the workspace is and where the
+  # index lives. Resolution mirrors coderag's load_config so both daemons
+  # agree on the db path for any given hub:
+  #
+  #   workspace_root:  explicit arg > coderag.yml's key > "." (the cwd — the
+  #                    lifecycle commands always run the daemon with cwd=hub)
+  #   storage_dir:     declared (workspace-relative unless absolute)
+  #                    > legacy <workspace>/.coderag when it already holds a db
+  #                    > the package data dir (~/.local/share/coderag/hubs/<hub>)
+  #
+  # All other coderag.yml keys (models, profiles, …) belong to the indexer and
+  # are ignored here — msnav never indexes.
+  class Config
+    attr_reader :workspace_root, :storage_dir, :config_source
+
+    def self.load(path = nil, workspace_root: nil)
+      candidates = []
+      candidates << Pathname.new(path) if path
+      env = ENV["CODERAG_CONFIG"]
+      candidates << Pathname.new(env) if env && !env.empty?
+      candidates << (Pathname.new(workspace_root) + "coderag.yml") if workspace_root
+      candidates << Pathname.new("coderag.yml")
+
+      data = {}
+      source = nil
+      candidates.each do |cand|
+        next unless cand.file?
+        begin
+          data = YAML.safe_load(cand.read) || {}
+        rescue Psych::SyntaxError => e
+          raise ConfigError, "#{cand}: invalid YAML — #{e.message}"
+        end
+        raise ConfigError, "#{cand}: top level must be a mapping" unless data.is_a?(Hash)
+        source = cand.expand_path
+        break
+      end
+
+      new(data, workspace_root: workspace_root, source: source)
+    end
+
+    def initialize(data, workspace_root: nil, source: nil)
+      @config_source = source
+      root = workspace_root || data["workspace_root"] || "."
+      @workspace_root = resolve(Pathname.new(File.expand_path(root.to_s)))
+
+      declared = data["storage_dir"]
+      if declared
+        dir = Pathname.new(declared.to_s.sub(/\A~/) { Dir.home })
+        dir = @workspace_root + dir unless dir.absolute?
+        @storage_dir = resolve(dir)
+      else
+        legacy = @workspace_root + ".coderag"
+        @storage_dir = if (legacy + "coderag.db").exist?
+                         legacy
+                       else
+                         Datadir.hub_dir(@workspace_root)
+                       end
+      end
+    end
+
+    def db_path
+      @storage_dir + "coderag.db"
+    end
+
+    private
+
+    # Pathname#realpath for what exists (symlink-stable, like Python's
+    # Path.resolve()); already-expanded path otherwise.
+    def resolve(pathname)
+      pathname.exist? ? pathname.realpath : pathname
+    end
+  end
+end

data/lib/msnav/ctl.rb

@@ -0,0 +1,203 @@
+# frozen_string_literal: true
+
+require "json"
+require "net/http"
+require "pathname"
+require "uri"
+require "yaml"
+
+module Msnav
+  # Daemon lifecycle control: the logic behind `msnav up/status/down` — a
+  # port of coderag/daemon/ctl.py with identical semantics and exit codes,
+  # so the editor extension can branch on them the same way.
+  module Ctl
+    PROBE_TIMEOUT = 2.0 # seconds per health request
+    SPAWN_GRACE = 3.0   # keep probing this long after our child dies (bind race)
+
+    # `up` exit codes (the extension and scripts branch on these)
+    EXIT_OK = 0
+    EXIT_FAIL = 1       # spawn failed / port held by a foreign process
+    EXIT_NO_HUB = 2     # no coderag.yml found — refuse to spawn
+    EXIT_WRONG_ROOT = 3 # healthy daemon on the port, but for another hub
+
+    # A leaked Bundler context (bundle exec / RUBYOPT=-rbundler/setup) makes
+    # rubygems binstubs refuse any gem not in the active Gemfile — the daemon
+    # never needs Bundler, so these are scrubbed from the child's environment.
+    BUNDLER_ENV = %w[RUBYOPT RUBYLIB BUNDLE_GEMFILE BUNDLE_BIN_PATH
+                     BUNDLER_VERSION BUNDLER_SETUP].freeze
+
+    Probe = Struct.new(:state, :health, :detail, keyword_init: true) do
+      def root
+        health && health["root"]
+      end
+
+      def pid
+        health && health["pid"]
+      end
+    end
+
+    module_function
+
+    # Nearest ancestor of START (inclusive) containing coderag.yml — the hub
+    # root a daemon may be spawned at. nil is the guard against rooting a
+    # daemon inside a single service directory.
+    def find_hub_root(start)
+      cur = Pathname.new(File.expand_path(start))
+      cur = cur.realpath if cur.exist?
+      loop do
+        return cur if (cur + "coderag.yml").file?
+        parent = cur.parent
+        return nil if parent == cur
+        cur = parent
+      end
+    end
+
+    # The workspace root a daemon started at HUB will report: coderag.yml's
+    # `workspace_root` key resolved against the hub, else the hub itself.
+    def expected_workspace_root(hub)
+      hub = Pathname.new(hub)
+      begin
+        data = YAML.safe_load((hub + "coderag.yml").read) || {}
+        declared = data.is_a?(Hash) ? data["workspace_root"] : nil
+        if declared
+          p = Pathname.new(declared.to_s.sub(/\A~/) { Dir.home })
+          candidate = p.absolute? ? p : hub + p
+          return candidate.exist? ? candidate.realpath : candidate.cleanpath
+        end
+      rescue StandardError
+        # a broken yml fails properly at daemon startup, not here
+      end
+      hub.exist? ? hub.realpath : hub
+    end
+
+    # One /api/health probe: healthy daemon, some foreign process, or nothing
+    # listening.
+    def probe_health(url, timeout = PROBE_TIMEOUT)
+      uri = URI.parse("#{url}/api/health")
+      body = nil
+      begin
+        http = Net::HTTP.new(uri.host, uri.port)
+        http.open_timeout = timeout
+        http.read_timeout = timeout
+        res = http.get(uri.request_uri)
+        unless res.is_a?(Net::HTTPSuccess)
+          return Probe.new(state: "foreign", health: {},
+                           detail: "HTTP #{res.code} from #{url}")
+        end
+        body = res.body
+      rescue StandardError => e
+        return Probe.new(state: "down", health: {}, detail: e.message)
+      end
+      health = begin
+        JSON.parse(body)
+      rescue JSON::ParserError
+        return Probe.new(state: "foreign", health: {},
+                         detail: "non-JSON response from #{url}")
+      end
+      unless health.is_a?(Hash) && health.key?("ok") && health.key?("root")
+        return Probe.new(state: "foreign", health: {},
+                         detail: "not a coderag daemon at #{url}")
+      end
+      Probe.new(state: "healthy", health: health, detail: "")
+    end
+
+    def same_root(a, b)
+      real(a.to_s) == real(b.to_s)
+    end
+
+    def real(path)
+      File.realpath(path)
+    rescue SystemCallError
+      File.expand_path(path)
+    end
+
+    # Where this hub's index/logs live — mirrors config resolution so the
+    # lifecycle commands know the log location before any daemon runs.
+    def resolved_storage(hub)
+      hub = Pathname.new(hub)
+      declared = nil
+      begin
+        data = YAML.safe_load((hub + "coderag.yml").read) || {}
+        declared = data.is_a?(Hash) ? data["storage_dir"] : nil
+      rescue StandardError
+        nil
+      end
+      root = expected_workspace_root(hub)
+      if declared
+        p = Pathname.new(declared.to_s.sub(/\A~/) { Dir.home })
+        return p.absolute? ? p : (root + p).cleanpath
+      end
+      legacy = root + ".coderag"
+      return legacy if (legacy + "coderag.db").exist?
+      Datadir.hub_dir(root)
+    end
+
+    # Raw stdout/stderr of a spawned daemon. Separate from coderag.log.
+    def daemon_log_path(hub)
+      resolved_storage(hub) + "daemon.log"
+    end
+
+    # The command that reruns THIS msnav — the gem binstub when we were
+    # started through one, else ruby + the packaged exe.
+    def self_command
+      exe = File.expand_path($PROGRAM_NAME)
+      return [exe] if File.file?(exe) && File.executable?(exe)
+      require "rbconfig"
+      ruby = File.join(RbConfig::CONFIG["bindir"],
+                       RbConfig::CONFIG["ruby_install_name"])
+      [ruby, File.expand_path("../../exe/msnav", __dir__)]
+    end
+
+    # Launch `msnav daemon` detached: new process group (outlives the
+    # caller), cwd = hub (so a relative workspace_root resolves there),
+    # output appended to daemon.log. Returns [pid, waiter_thread].
+    def spawn_daemon(hub, config_path, host, port,
+                     service_root: nil, service_name: nil, log_path: nil)
+      log_path = log_path || daemon_log_path(hub)
+      log_path.parent.mkpath
+      argv = self_command + ["daemon", "--config", config_path.to_s,
+                             "--host", host, "--port", port.to_s]
+      argv += ["--service-root", service_root.to_s] if service_root
+      argv += ["--service", service_name.to_s] if service_name
+      log_file = File.open(log_path.to_s, "ab")
+      begin
+        scrub = BUNDLER_ENV.each_with_object({}) { |k, h| h[k] = nil }
+        pid = Process.spawn(scrub, *argv, chdir: hub.to_s, pgroup: true,
+                            in: File::NULL, out: log_file, err: log_file)
+      ensure
+        log_file.close # the child holds its own fd
+      end
+      [pid, Process.detach(pid)]
+    end
+
+    # Poll until something answers health or the deadline passes. A dead
+    # child is NOT failure by itself: losing the port-bind race to another
+    # window's daemon is success as long as a healthy daemon appears — the
+    # caller compares roots. After the child dies we keep probing briefly.
+    def wait_healthy(url, waiter, timeout, poll = 0.25)
+      deadline = monotonic + timeout
+      died_at = nil
+      loop do
+        probe = probe_health(url, [PROBE_TIMEOUT, poll * 4].min)
+        return probe unless probe.state == "down"
+        now = monotonic
+        died_at = now if waiter && !waiter.alive? && died_at.nil?
+        if now >= deadline || (!died_at.nil? && now - died_at > SPAWN_GRACE)
+          return probe
+        end
+        sleep poll
+      end
+    end
+
+    def tail_log(log_path, lines = 20)
+      content = File.read(log_path.to_s).split("\n")
+      content.last(lines).join("\n")
+    rescue SystemCallError
+      ""
+    end
+
+    def monotonic
+      Process.clock_gettime(Process::CLOCK_MONOTONIC)
+    end
+  end
+end

data/lib/msnav/datadir.rb

@@ -0,0 +1,121 @@
+# frozen_string_literal: true
+
+require "digest"
+require "pathname"
+require "sqlite3"
+
+module Msnav
+  # Package-owned data directory — mirrors coderag/datadir.py exactly, so an
+  # index built by `coderag index` on the host is found at the same place
+  # inside the container (the one uniform bind mount:
+  # ~/.local/share/coderag -> /root/.local/share/coderag).
+  module Datadir
+    module_function
+
+    def data_dir
+      override = ENV["CODERAG_DATA_DIR"]
+      return Pathname.new(File.expand_path(override)) if override && !override.empty?
+      xdg = ENV["XDG_DATA_HOME"]
+      base = xdg && !xdg.empty? ? Pathname.new(File.expand_path(xdg)) : Pathname.new(Dir.home) + ".local" + "share"
+      base + "coderag"
+    end
+
+    # The hub's slice of the data dir: readable name + path-hash suffix.
+    # Must match coderag's sha256(str(resolved_root))[:10].
+    def hub_dir(workspace_root)
+      root = Pathname.new(File.expand_path(workspace_root))
+      root = root.realpath if root.exist?
+      key = Digest::SHA256.hexdigest(root.to_s)[0, 10]
+      data_dir + "hubs" + "#{root.basename}-#{key}"
+    end
+
+    # content matching: enough overlap between the index's cached file paths
+    # and the files actually on disk to be sure this folder IS that service
+    MATCH_MIN_FILES = 3
+    MATCH_MIN_RATIO = 0.6
+    SAMPLE_LIMIT = 2000
+    SKIP_DIRS = %w[.git vendor node_modules tmp log spec test].freeze
+
+    # Relative .rb paths under SERVICE_ROOT (bounded walk).
+    def disk_ruby_files(service_root)
+      found = {}
+      queue = [Pathname.new(service_root)]
+      root = Pathname.new(service_root)
+      until queue.empty?
+        dir = queue.shift
+        children = begin
+          dir.children
+        rescue SystemCallError
+          next
+        end
+        children.each do |entry|
+          if entry.directory?
+            queue << entry unless SKIP_DIRS.include?(entry.basename.to_s)
+          elsif entry.extname == ".rb"
+            found[entry.relative_path_from(root).to_s.tr(File::SEPARATOR, "/")] = true
+            return found if found.length >= SAMPLE_LIMIT
+          end
+        end
+      end
+      found
+    end
+
+    # Which indexed service (dirname) does SERVICE_ROOT hold? Directory-name
+    # match first; otherwise by content — the service whose cached file paths
+    # are actually present on disk (mounts like `/app` don't carry the
+    # service name). Mirrors coderag's datadir.identify_service.
+    def identify_service(db_path, service_root)
+      service_root = Pathname.new(service_root)
+      con = begin
+        SQLite3::Database.new(db_path.to_s, readonly: true)
+      rescue SQLite3::Exception
+        return nil
+      end
+      begin
+        dirnames = begin
+          con.execute("SELECT dirname FROM services").map { |r| r[0] }
+        rescue SQLite3::Exception
+          return nil
+        end
+        base = service_root.basename.to_s
+        return base if dirnames.include?(base)
+        disk = disk_ruby_files(service_root)
+        return nil if disk.empty?
+        best = nil
+        dirnames.each do |dirname|
+          paths = begin
+            con.execute("SELECT path FROM facts WHERE service = ?", [dirname])
+               .map { |r| r[0] }
+          rescue SQLite3::Exception
+            return nil
+          end
+          present = paths.count { |p| disk.key?(p) }
+          next if present < MATCH_MIN_FILES || paths.empty?
+          ratio = present.to_f / paths.length
+          if ratio >= MATCH_MIN_RATIO && (best.nil? || ratio > best[0])
+            best = [ratio, dirname]
+          end
+        end
+        best && best[1]
+      ensure
+        con.close
+      end
+    end
+
+    # [hub dir, service dirname] candidates for the service at SERVICE_ROOT —
+    # how a service-only container identifies its hub with nothing but the
+    # data-dir mount.
+    def find_hubs_for_service_root(service_root)
+      hubs = data_dir + "hubs"
+      return [] unless hubs.directory?
+      matches = []
+      hubs.children.sort.each do |hub|
+        db = hub + "coderag.db"
+        next unless db.file?
+        dirname = identify_service(db, service_root)
+        matches << [hub, dirname] if dirname
+      end
+      matches
+    end
+  end
+end

data/lib/msnav/errors.rb

@@ -0,0 +1,11 @@
+# frozen_string_literal: true
+
+module Msnav
+  class Error < StandardError; end
+
+  # The index is missing, foreign, or from an incompatible coderag schema.
+  class IndexStaleError < Error; end
+
+  # coderag.yml could not be parsed into the keys msnav needs.
+  class ConfigError < Error; end
+end

data/lib/msnav/graph.rb

@@ -0,0 +1,151 @@
+# frozen_string_literal: true
+
+require "json"
+
+module Msnav
+  # In-memory view of the coderag code graph (nodes/edges tables), with the
+  # same secondary indexes coderag builds: by-kind, per-(service, file) node
+  # lists, and per-file line-interval lists for covering-symbol lookup.
+  #
+  # Node data and edge data are the JSON hashes coderag persisted (string
+  # keys); an edge's "kind" column is merged back into its data hash, exactly
+  # like CodeGraph.load does in Python.
+  class Graph
+    attr_reader :nodes
+
+    # Load the graph and re-anchor service roots when the same workspace is
+    # mounted at a different path than at index time (host <-> container).
+    # Each root is rebased only if the rebased directory actually exists — a
+    # container that mounts only the data dir keeps the stored host paths and
+    # serves them verbatim (the service-scoped devcontainer flow).
+    def self.load(store, workspace_root = nil)
+      nodes = {}
+      out_edges = Hash.new { |h, k| h[k] = [] }
+      in_edges = Hash.new { |h, k| h[k] = [] }
+      stored_ws = nil
+      store.with_conn do |db|
+        db.execute("SELECT id, data FROM nodes") do |id, data|
+          nodes[id] = JSON.parse(data)
+        end
+        db.execute("SELECT src, dst, kind, data FROM edges") do |src, dst, kind, data|
+          edge = JSON.parse(data)
+          edge["kind"] = kind
+          nodes[src] ||= {} # edges may reference nodes with no attributes
+          nodes[dst] ||= {}
+          out_edges[src] << [dst, edge]
+          in_edges[dst] << [src, edge]
+        end
+        row = db.get_first_row("SELECT value FROM meta WHERE key='workspace_root'")
+        stored_ws = row && row[0]
+      end
+      graph = new(nodes, out_edges, in_edges)
+      graph.rebase_roots(stored_ws, workspace_root.to_s) if workspace_root
+      graph
+    end
+
+    def initialize(nodes, out_edges, in_edges)
+      @nodes = nodes
+      @out_edges = out_edges
+      @in_edges = in_edges
+      build_indexes
+    end
+
+    def node(node_id)
+      @nodes[node_id]
+    end
+
+    def has_node?(node_id)
+      @nodes.key?(node_id)
+    end
+
+    # Outgoing [dst, edge_data] pairs, optionally filtered to edge kinds.
+    def out(node_id, kinds = nil)
+      edges = @out_edges[node_id] || []
+      return edges if kinds.nil?
+      edges.select { |_dst, data| kinds.include?(data["kind"]) }
+    end
+
+    # Incoming [src, edge_data] pairs (cross-service references).
+    def in_edges(node_id)
+      @in_edges[node_id] || []
+    end
+
+    def nodes_of_kind(kind)
+      (@by_kind[kind] || []).map { |id| [id, @nodes[id]] }
+    end
+
+    def nodes_in_file(service, file)
+      (@by_service_file[[service, file]] || []).map { |id| [id, @nodes[id]] }
+    end
+
+    def services
+      nodes_of_kind("service")
+    end
+
+    def endpoints(service = nil)
+      nodes_of_kind("endpoint").select do |_id, data|
+        service.nil? || data["service"] == service
+      end
+    end
+
+    # Smallest node whose line span covers `line` (1-based) in the file's
+    # interval list. Ties break toward the later start line, matching the
+    # Python bisect walk.
+    def covering_symbol(service, file, line)
+      spans = @intervals[[service, file]] || []
+      best = nil
+      spans.reverse_each do |start_line, end_line, node_id|
+        next if start_line > line
+        next if end_line < line
+        size = end_line - start_line
+        best = [size, node_id] if best.nil? || size < best[0]
+      end
+      best && best[1]
+    end
+
+    # Re-anchor service roots from the workspace root stored at index time to
+    # WORKSPACE_ROOT. No-op when they match, the meta key is missing, or the
+    # rebased directory does not exist.
+    def rebase_roots(stored_ws, workspace_root)
+      ws = File.expand_path(workspace_root)
+      return if stored_ws.nil? || stored_ws.empty?
+      return if File.expand_path(stored_ws) == ws
+      stored = Pathname.new(File.expand_path(stored_ws))
+      services.each do |_id, data|
+        root = data["root"]
+        next if root.nil? || root.empty?
+        begin
+          rel = Pathname.new(File.expand_path(root)).relative_path_from(stored).to_s
+        rescue ArgumentError
+          next
+        end
+        next if rel.start_with?("..")
+        candidate = rel == "." ? ws : File.join(ws, rel)
+        data["root"] = candidate if File.directory?(candidate)
+      end
+      build_indexes
+    end
+
+    private
+
+    def build_indexes
+      @by_kind = {}
+      @by_service_file = {}
+      @intervals = {}
+      @nodes.each do |id, data|
+        kind = data["kind"]
+        (@by_kind[kind] ||= []) << id if kind
+        service = data["service"]
+        file = data["file"]
+        next unless service && file
+        key = [service, file]
+        (@by_service_file[key] ||= []) << id
+        start_line = data["start_line"] || data["line"]
+        next if start_line.nil?
+        end_line = data["end_line"] || start_line
+        (@intervals[key] ||= []) << [start_line, end_line, id]
+      end
+      @intervals.each_value(&:sort!)
+    end
+  end
+end