okf 1.9.0 → 1.11.0

data/lib/okf/render/graph.rb

@@ -71,9 +71,11 @@ module OKF
       # +siblings+/+self_slug+/+hub_path+ carry the hub's bundle switcher into the
       # page (server mode only). nil — the standalone-server and `okf render`
       # default — injects an empty SIBLINGS, so the switcher never appears in a
-      # single bundle or a static file.
+      # single bundle or a static file. +search_endpoint+ rides along with them:
+      # the hub's cross-bundle /search, which only a hub can answer.
       def initialize(graph, title: nil, link: nil, layout: "cose", node_endpoint: "node", meta_endpoint: "node/meta", embed: nil,
-                     siblings: nil, self_slug: nil, hub_path: nil)
+                     siblings: nil, self_slug: nil, hub_path: nil, search_endpoint: nil,
+                     manage_root: nil, manage_token: nil)
         @graph = graph
         @title = title
         @link = link
@@ -84,6 +86,9 @@ module OKF
         @siblings = siblings
         @self_slug = self_slug
         @hub_path = hub_path
+        @search_endpoint = search_endpoint
+        @manage_root = manage_root
+        @manage_token = manage_token
       end
 
       def render
@@ -158,6 +163,45 @@ module OKF
         json_for_script(@hub_path)
       end
 
+      # The hub's cross-bundle /search, mount-relative — null everywhere else, and
+      # that null is the gate: a standalone server and a static file have no set
+      # of bundles to search, so the palette never offers concepts there.
+      def search_endpoint_json
+        json_for_script(@search_endpoint)
+      end
+
+      # Behind a hub the mark is a link back to the bundle list — "../" reaches
+      # it under any mount, because every page lives at <prefix>/b/<slug>/.
+      # Standalone and static have nowhere to go, so there it stays the plain
+      # identity badge it has always been, and an <a href> to nothing is worse
+      # than no <a> at all.
+      def rail_brand_open
+        return %(<span class="rail-brand" title=") unless @manage_root
+
+        %(<a class="rail-brand" href="../" aria-label="All bundles" title=")
+      end
+
+      def rail_brand_close
+        @manage_root ? "</a>" : "</span>"
+      end
+
+      # The hub root, mount-relative — where the Bundles panel reads /bundles and
+      # posts /registry/<verb>. Null everywhere else, and that null is the gate:
+      # a standalone server and a static file have no registry behind them, so
+      # the panel never appears there.
+      def manage_root_json
+        json_for_script(@manage_root)
+      end
+
+      # This boot's CSRF token, and only where a write could be honoured — a
+      # read-only hub bakes null, so the page holds no credential it may not use.
+      # It is no wider than the /b/ manager, which any script on this origin
+      # could already read; keeping it out of the page where it is useless is
+      # tidiness, not a boundary.
+      def manage_token_json
+        json_for_script(@manage_token)
+      end
+
       # JSON-encode for safe embedding in an inline <script>: escaping every `<` to
       # its JSON unicode escape neutralizes </script>, <!-- and <script in one
       # stroke, and the result stays valid JSON *and* JavaScript.

data/lib/okf/server/app.rb

@@ -30,12 +30,59 @@ module OKF
     #   GET /log            the §7 history for the Log panel: { logs: [ {path,
     #                       dir, content} ] } (JSON; content read live from disk,
     #                       like a body — the log is the file that changes most)
+    #   GET /search?q=…     ranked concepts in this bundle, for the ⌘K palette:
+    #                       { query, total, truncated, results: [ …rows… ] } (JSON)
     class App
+      # How many rows /search answers with. The palette shows a handful and the
+      # rest is scroll nobody reaches, but the count is reported alongside so a
+      # capped answer never reads as a complete one.
+      SEARCH_LIMIT = 50
+
+      # The engine /search runs on, named rather than inferred. `fuzzy: true`
+      # would route here on its own today — the index is the only registered
+      # engine that offers it — but that is correctness by coincidence, and an
+      # addon declaring :fuzzy would silently take the route.
+      #
+      # It is also the *right* engine here for a reason the CLI's default does
+      # not share: `okf search` is one-shot and cannot amortize an index build,
+      # while this is a long-lived server answering keystroke after keystroke.
+      # And the page's own MiniSearch is what minifts is a port of, so a palette
+      # hit and an in-page search rank alike instead of nearly alike.
+      SEARCH_ENGINE = :index
+
+      # The /search payload, defined once because two hosts answer it: this one
+      # bundle, or every bundle the hub hosts. The only difference is the corpus
+      # handed in — and a nil slug drops the `slug` key from a row, so a
+      # standalone server never answers as if it were a set.
+      #
+      # It takes a prepared corpus rather than the pairs, because that is what
+      # makes the index survive the request that built it.
+      def self.search_payload(corpus, query)
+        terms = query.to_s.split(/\s+/).reject(&:empty?)
+        rows = terms.empty? ? [] : OKF::Bundle::Search.with(corpus, terms, fuzzy: true, engine: SEARCH_ENGINE)
+        {
+          "query" => query.to_s.strip,
+          "total" => rows.length,
+          "truncated" => rows.length > SEARCH_LIMIT,
+          "results" => rows.first(SEARCH_LIMIT)
+        }
+      end
+
       # +siblings+/+self_slug+/+hub_path+ are set only when this app is hosted under
       # a hub (OKF::Server::Hub): the other bundles the in-page switcher offers, this
-      # bundle's own mount slug, and the hub root. They stay nil for a standalone
-      # server and for `okf render`, so a static file never advertises a switcher.
-      def initialize(folder, title: nil, link: nil, layout: "cose", siblings: nil, self_slug: nil, hub_path: nil)
+      # bundle's own mount slug, the hub root, and the hub's cross-bundle search
+      # route. They stay nil for a standalone server and for `okf render`, so a
+      # static file never advertises a switcher or a search it cannot answer.
+      #
+      # +search_endpoint+ belongs to that group for the same reason, even though
+      # this app now answers /search itself: the page resolves it *relative to the
+      # URL the reader is on*, so only whoever mounted the app knows what to call
+      # it. `okf server` mounts at the root and passes "search"; a host doing
+      # `mount App.new(folder) => "/knowledge"` needs its own spelling, and a
+      # default would have pointed its palette at the host's root instead. The
+      # route answers either way — advertising it is the caller's call.
+      def initialize(folder, title: nil, link: nil, layout: "cose", siblings: nil, self_slug: nil, hub_path: nil,
+                     search_endpoint: nil, manage_root: nil, manage_token: nil)
         @folder = folder
         @title = title
         @link = link
@@ -43,6 +90,17 @@ module OKF
         @siblings = siblings
         @self_slug = self_slug
         @hub_path = hub_path
+        @search_endpoint = search_endpoint
+        @manage_root = manage_root
+        @manage_token = manage_token
+      end
+
+      # Build the search index now rather than on the first reader's keystroke.
+      # `okf server` calls this after the bundle is loaded, so the cost lands in
+      # boot — where it is expected and attributable — instead of in a request.
+      def warm_search
+        search_corpus
+        self
       end
 
       def call(env)
@@ -58,6 +116,7 @@ module OKF
         when "/types" then respond_json(graph.type_index)
         when "/index" then respond_json(directory_index)
         when "/log" then respond_json(logs)
+        when "/search" then respond_json(self.class.search_payload(search_corpus, request.params["q"]))
         else not_found
         end
       end
@@ -100,7 +159,8 @@ module OKF
       def page
         @page ||= OKF::Render::Graph.new(
           graph, title: @title || @folder.name, link: @link, layout: @layout,
-          siblings: @siblings, self_slug: @self_slug, hub_path: @hub_path
+          siblings: @siblings, self_slug: @self_slug, hub_path: @hub_path, search_endpoint: @search_endpoint,
+          manage_root: @manage_root, manage_token: @manage_token
         ).render
       end
 
@@ -141,6 +201,13 @@ module OKF
         [ 200, { "content-type" => content_type }, [ body.to_s ] ]
       end
 
+      # Built on the first search and held for the life of the app, the way the
+      # graph is. `okf server` warms it at boot so the first reader does not pay
+      # for the whole corpus.
+      def search_corpus
+        @search_corpus ||= OKF::Bundle::Search.prepare([ [ nil, @folder.bundle ] ], engine: SEARCH_ENGINE)
+      end
+
       def respond_json(object)
         respond("application/json; charset=utf-8", JSON.generate(object))
       end