claude_memory 0.9.1 → 0.11.0

data/lib/claude_memory/dashboard/server.rb

@@ -0,0 +1,211 @@
+# frozen_string_literal: true
+
+require "webrick"
+require "json"
+
+module ClaudeMemory
+  module Dashboard
+    class Server
+      DEFAULT_PORT = 3377
+
+      def initialize(manager:, port: DEFAULT_PORT, open_browser: true)
+        @manager = manager
+        @port = port
+        @open_browser = open_browser
+        @server = nil
+      end
+
+      def start
+        @server = WEBrick::HTTPServer.new(
+          Port: @port,
+          Logger: WEBrick::Log.new(File::NULL),
+          AccessLog: []
+        )
+
+        mount_routes
+
+        trap("INT") { @server.shutdown }
+        trap("TERM") { @server.shutdown }
+
+        open_browser if @open_browser
+        @server.start
+      end
+
+      def stop
+        @server&.shutdown
+      end
+
+      private
+
+      def mount_routes
+        api = API.new(@manager)
+
+        @server.mount_proc("/") { |_req, res| serve_html(res) }
+        @server.mount_proc("/api/health") { |_req, res| with_fresh_connections { json_response(res, api.health) } }
+        @server.mount_proc("/api/stats") { |_req, res| with_fresh_connections { json_response(res, api.stats) } }
+        @server.mount_proc("/api/activity") { |req, res|
+          with_fresh_connections {
+            if (id = activity_id_from_path(req.path))
+              json_response(res, api.activity_detail(id))
+            else
+              json_response(res, api.activity(req.query))
+            end
+          }
+        }
+        @server.mount_proc("/api/facts") { |req, res| with_fresh_connections { handle_facts(api, req, res) } }
+        @server.mount_proc("/api/efficacy") { |req, res| with_fresh_connections { json_response(res, api.efficacy(req.query)) } }
+        @server.mount_proc("/api/session") { |req, res|
+          with_fresh_connections {
+            session_id = req.query["session_id"]
+            json_response(res, api.session_summary(session_id))
+          }
+        }
+        @server.mount_proc("/api/timeline") { |_req, res| with_fresh_connections { json_response(res, api.timeline) } }
+        @server.mount_proc("/api/recall") { |req, res| with_fresh_connections { json_response(res, api.recall(req.query)) } }
+        @server.mount_proc("/api/conflicts") { |req, res| with_fresh_connections { handle_conflicts(api, req, res) } }
+        @server.mount_proc("/api/moments") { |req, res| with_fresh_connections { handle_moments(api, req, res) } }
+        @server.mount_proc("/api/trust") { |_req, res| with_fresh_connections { json_response(res, api.trust) } }
+        @server.mount_proc("/api/knowledge") { |req, res| with_fresh_connections { json_response(res, api.knowledge(req.query)) } }
+        @server.mount_proc("/api/reuse") { |req, res| with_fresh_connections { json_response(res, api.reuse(req.query)) } }
+      end
+
+      # WAL-mode SQLite caches pages on reader connections; when the MCP
+      # server (or hooks, or any other writer) modifies the same DB
+      # concurrently, long-lived dashboard connections can see stale pages
+      # and surface "database disk image is malformed" errors even though
+      # PRAGMA integrity_check reports ok. Releasing connections after each
+      # HTTP request forces a fresh connection on the next read, matching
+      # what MCP::Server#release_connections does per tool call.
+      def with_fresh_connections
+        yield
+      ensure
+        release_connections
+      end
+
+      def release_connections
+        return unless @manager
+        @manager.global_store&.db&.disconnect
+        @manager.project_store&.db&.disconnect
+      rescue Sequel::DatabaseError, Extralite::Error
+        # Best-effort; next call will reopen.
+      end
+
+      def handle_moments(api, req, res)
+        feedback_id = moment_feedback_id_from_path(req.path)
+
+        if feedback_id && req.request_method == "POST"
+          body = parse_json_body(req)
+          json_response(res, api.moment_feedback(feedback_id, verdict: body["verdict"], note: body["note"]))
+        elsif feedback_id && req.request_method == "DELETE"
+          json_response(res, api.clear_moment_feedback(feedback_id))
+        else
+          json_response(res, api.moments(req.query))
+        end
+      end
+
+      def moment_feedback_id_from_path(path)
+        match = path.match(%r{\A/api/moments/(\d+)/feedback\z})
+        match && match[1]
+      end
+
+      def handle_conflicts(api, req, res)
+        reject_id = conflict_reject_id_from_path(req.path)
+        detail_id = conflict_id_from_path(req.path)
+        is_reject_similar = req.path == "/api/conflicts/reject_similar"
+
+        if req.request_method == "POST" && is_reject_similar
+          body = parse_json_body(req)
+          keeper_id = body["keeper_fact_id"]
+          reason = body["reason"]
+          scope = body["scope"] || req.query["scope"] || "project"
+          json_response(res, api.reject_similar_conflicts(keeper_id, reason: reason, scope: scope))
+        elsif req.request_method == "POST" && reject_id
+          body = parse_json_body(req)
+          side = body["side"]
+          reason = body["reason"]
+          scope = body["scope"] || req.query["scope"] || "project"
+          json_response(res, api.reject_conflict_fact(reject_id, side: side, reason: reason, scope: scope))
+        elsif detail_id
+          scope = req.query["scope"] || "project"
+          json_response(res, api.conflict_detail(detail_id, scope))
+        else
+          json_response(res, api.conflicts(req.query))
+        end
+      end
+
+      def parse_json_body(req)
+        return {} if req.body.nil? || req.body.empty?
+        JSON.parse(req.body)
+      rescue JSON::ParserError
+        {}
+      end
+
+      def serve_html(res)
+        html_path = File.expand_path("index.html", __dir__)
+        res["Content-Type"] = "text/html; charset=utf-8"
+        res.body = File.read(html_path)
+      end
+
+      def activity_id_from_path(path)
+        match = path.match(%r{\A/api/activity/(\d+)\z})
+        match && match[1]
+      end
+
+      def fact_id_from_path(path)
+        match = path.match(%r{\A/api/facts/(\d+)\z})
+        match && match[1]
+      end
+
+      def fact_action_from_path(path)
+        match = path.match(%r{\A/api/facts/(\d+)/(reject|promote)\z})
+        match ? [match[1], match[2]] : nil
+      end
+
+      def handle_facts(api, req, res)
+        action = fact_action_from_path(req.path)
+        detail_id = fact_id_from_path(req.path)
+
+        if req.request_method == "POST" && action
+          fact_id, verb = action
+          body = parse_json_body(req)
+          scope = body["scope"] || req.query["scope"] || "project"
+          case verb
+          when "reject"
+            json_response(res, api.reject_fact(fact_id, reason: body["reason"], scope: scope))
+          when "promote"
+            json_response(res, api.promote_fact(fact_id))
+          end
+        elsif detail_id
+          scope = req.query["scope"] || "project"
+          json_response(res, api.fact_detail(detail_id, scope))
+        else
+          json_response(res, api.facts(req.query))
+        end
+      end
+
+      def conflict_id_from_path(path)
+        match = path.match(%r{\A/api/conflicts/(\d+)\z})
+        match && match[1]
+      end
+
+      def conflict_reject_id_from_path(path)
+        match = path.match(%r{\A/api/conflicts/(\d+)/reject\z})
+        match && match[1]
+      end
+
+      def json_response(res, data)
+        res["Content-Type"] = "application/json; charset=utf-8"
+        res["Access-Control-Allow-Origin"] = "*"
+        res.body = JSON.generate(data)
+      end
+
+      def open_browser
+        url = "http://localhost:#{@port}"
+        Thread.new do
+          sleep 0.5
+          system("open", url) || system("xdg-open", url) || system("start", url)
+        end
+      end
+    end
+  end
+end

data/lib/claude_memory/dashboard/timeline.rb

@@ -0,0 +1,68 @@
+# frozen_string_literal: true
+
+module ClaudeMemory
+  module Dashboard
+    # Daily activity rollup for the dashboard timeline view. Aggregates three
+    # event sources (fact creation, content ingestion, activity events) into
+    # per-day buckets covering the last 30 days. Returns the empty shape
+    # ({days: []}) when no project store is available so the dashboard can
+    # render before the first ingest.
+    class Timeline
+      LOOKBACK_DAYS = 30
+
+      def initialize(manager)
+        @manager = manager
+      end
+
+      def days
+        store = @manager.default_store(prefer: :project)
+        return {days: []} unless store
+
+        cutoff = (Time.now - LOOKBACK_DAYS * 86_400).utc.iso8601
+        {days: build_days(store, cutoff)}
+      end
+
+      private
+
+      def build_days(store, cutoff)
+        fact_rows = group_count(store.facts, cutoff_field: :created_at, cutoff: cutoff)
+        content_rows = group_count(store.content_items, cutoff_field: :ingested_at, cutoff: cutoff)
+        event_rows = activity_event_rows(store, cutoff)
+
+        all_days = (fact_rows + content_rows + event_rows).map { |r| r[:day] }.uniq.sort
+        all_days.map { |day| compose_day(day, fact_rows, content_rows, event_rows) }
+      end
+
+      def group_count(dataset, cutoff_field:, cutoff:)
+        dataset
+          .where { Sequel[cutoff_field] >= cutoff }
+          .select_group(Sequel.lit("DATE(#{cutoff_field})").as(:day))
+          .select_append { count(id).as(:count) }
+          .order(:day)
+          .all
+      end
+
+      def activity_event_rows(store, cutoff)
+        return [] unless store.db.table_exists?(:activity_events)
+
+        store.activity_events
+          .where { occurred_at >= cutoff }
+          .select_group(Sequel.lit("DATE(occurred_at)").as(:day), :event_type)
+          .select_append { count(id).as(:count) }
+          .order(:day)
+          .all
+      end
+
+      def compose_day(day, fact_rows, content_rows, event_rows)
+        day_events = event_rows.select { |r| r[:day] == day }
+        {
+          date: day,
+          facts_created: fact_rows.find { |r| r[:day] == day }&.dig(:count) || 0,
+          content_ingested: content_rows.find { |r| r[:day] == day }&.dig(:count) || 0,
+          hook_events: day_events.sum { |r| r[:count] },
+          recalls: day_events.select { |r| r[:event_type] == "recall" }.sum { |r| r[:count] }
+        }
+      end
+    end
+  end
+end