claude_memory 0.7.1 → 0.9.0

data/lib/claude_memory/mcp/handlers/management_handlers.rb

@@ -0,0 +1,169 @@
+# frozen_string_literal: true
+
+module ClaudeMemory
+  module MCP
+    module Handlers
+      # Management tool handlers (store_extraction, promote, sweep, changes, conflicts)
+      module ManagementHandlers
+        def store_extraction(args)
+          scope = args["scope"] || "project"
+          store = get_store_for_scope(scope)
+          return {error: "Database not available"} unless store
+
+          entities = (args["entities"] || []).map { |e| symbolize_keys(e) }
+          facts = (args["facts"] || []).map { |f| symbolize_keys(f) }
+          decisions = (args["decisions"] || []).map { |d| symbolize_keys(d) }
+
+          config = Configuration.new
+          project_path = config.project_dir
+          occurred_at = Time.now.utc.iso8601
+
+          searchable_text = Core::TextBuilder.build_searchable_text(entities, facts, decisions)
+          content_item_id = create_synthetic_content_item(store, searchable_text, project_path, occurred_at)
+          index_content_item(store, content_item_id, searchable_text)
+
+          extraction = Distill::Extraction.new(
+            entities: entities,
+            facts: facts,
+            decisions: decisions,
+            signals: []
+          )
+
+          resolver = Resolve::Resolver.new(store)
+          result = resolver.apply(
+            extraction,
+            content_item_id: content_item_id,
+            occurred_at: occurred_at,
+            project_path: project_path,
+            scope: scope
+          )
+
+          {
+            success: true,
+            scope: scope,
+            entities_created: result[:entities_created],
+            facts_created: result[:facts_created],
+            facts_superseded: result[:facts_superseded],
+            conflicts_created: result[:conflicts_created]
+          }
+        end
+
+        def promote(args)
+          return {error: "Promote requires StoreManager"} unless @manager
+
+          fact_id = args["fact_id"]
+          global_fact_id = @manager.promote_fact(fact_id)
+
+          if global_fact_id
+            {
+              success: true,
+              project_fact_id: fact_id,
+              global_fact_id: global_fact_id,
+              message: "Fact promoted to global memory"
+            }
+          else
+            {error: "Fact #{fact_id} not found in project database"}
+          end
+        end
+
+        def reject_fact(args)
+          scope = args["scope"] || "project"
+          store = get_store_for_scope(scope)
+          return {error: "Database not available"} unless store
+
+          fact_id = args["fact_id"]
+          if fact_id.nil? && args["docid"]
+            row = store.find_fact_by_docid(args["docid"])
+            fact_id = row && row[:id]
+          end
+          return {error: "fact_id or docid required"} if fact_id.nil?
+
+          result = store.reject_fact(fact_id, reason: args["reason"])
+          return {error: "Fact #{fact_id} not found in #{scope} database"} if result.nil?
+
+          {
+            success: true,
+            scope: scope,
+            fact_id: fact_id,
+            conflicts_resolved: result[:conflicts_resolved],
+            message: "Fact rejected"
+          }
+        end
+
+        def sweep_now(args)
+          scope = args["scope"] || "project"
+          store = get_store_for_scope(scope)
+          return {error: "Database not available"} unless store
+
+          sweeper = Sweep::Sweeper.new(store)
+          budget = args["budget_seconds"] || 5
+          stats = if args["escalate"]
+            sweeper.run_with_escalation!(budget_seconds: budget)
+          else
+            sweeper.run!(budget_seconds: budget)
+          end
+          ResponseFormatter.format_sweep_stats(scope, stats)
+        end
+
+        def changes(args)
+          since = args["since"] || (Time.now - 86400 * 7).utc.iso8601
+          scope = args["scope"] || "all"
+          list = @recall.changes(since: since, limit: args["limit"] || 20, scope: scope)
+          ResponseFormatter.format_changes(since, list)
+        end
+
+        def conflicts(args)
+          scope = args["scope"] || "all"
+          list = @recall.conflicts(scope: scope)
+          ResponseFormatter.format_conflicts(list)
+        end
+
+        def mark_distilled(args)
+          content_item_id = args["content_item_id"]
+          facts_extracted = args["facts_extracted"] || 0
+
+          store = find_store_for_content_item(content_item_id)
+          return {error: "Content item #{content_item_id} not found"} unless store
+
+          store.record_ingestion_metrics(
+            content_item_id: content_item_id,
+            input_tokens: 0,
+            output_tokens: 0,
+            facts_extracted: facts_extracted
+          )
+
+          {
+            success: true,
+            content_item_id: content_item_id,
+            facts_extracted: facts_extracted
+          }
+        end
+
+        private
+
+        def create_synthetic_content_item(store, text, project_path, occurred_at)
+          text_hash = Digest::SHA256.hexdigest(text)
+          store.upsert_content_item(
+            source: "mcp_extraction",
+            session_id: "mcp-#{Time.now.to_i}",
+            transcript_path: nil,
+            project_path: project_path,
+            text_hash: text_hash,
+            byte_len: text.bytesize,
+            raw_text: text,
+            occurred_at: occurred_at
+          )
+        end
+
+        def index_content_item(store, content_item_id, text)
+          fts = Index::LexicalFTS.new(store)
+          fts.index_content_item(content_item_id, text)
+        end
+
+        def symbolize_keys(hash)
+          Core::TextBuilder.symbolize_keys(hash)
+        end
+      end
+    end
+  end
+end

data/lib/claude_memory/mcp/handlers/query_handlers.rb

@@ -0,0 +1,115 @@
+# frozen_string_literal: true
+
+module ClaudeMemory
+  module MCP
+    module Handlers
+      # Query and recall tool handlers
+      module QueryHandlers
+        def recall(args)
+          return database_not_found_error unless databases_exist?
+
+          scope = extract_scope(args)
+          limit = extract_limit(args)
+          compact = args["compact"] == true
+          query = args["query"]
+          intent = extract_intent(args)
+          results = @recall.query(query, limit: limit, scope: scope, include_raw_text: !compact, intent: intent)
+          ResponseFormatter.format_recall_results(results, compact: compact, query: query)
+        rescue Sequel::DatabaseError, Sequel::DatabaseConnectionError, Errno::ENOENT => e
+          classified_error(e, tool_name: "memory.recall")
+        end
+
+        def recall_index(args)
+          scope = extract_scope(args)
+          limit = extract_limit(args, default: 20)
+          intent = extract_intent(args)
+          results = @recall.query_index(args["query"], limit: limit, scope: scope, intent: intent)
+          ResponseFormatter.format_index_results(args["query"], scope, results)
+        end
+
+        def recall_details(args)
+          fact_ids = args["fact_ids"]
+          scope = args["scope"] || "project"
+
+          explanations = fact_ids.map do |fact_id|
+            explanation = @recall.explain(fact_id, scope: scope)
+            next nil if explanation.is_a?(Core::NullExplanation)
+
+            ResponseFormatter.format_detailed_explanation(explanation)
+          end.compact
+
+          {
+            fact_count: explanations.size,
+            facts: explanations
+          }
+        end
+
+        def explain(args)
+          scope = args["scope"] || "project"
+          explanation = @recall.explain(args["fact_id"], scope: scope)
+          return {error: "Fact not found in #{scope} database"} if explanation.is_a?(Core::NullExplanation)
+
+          ResponseFormatter.format_explanation(explanation, scope)
+        end
+
+        def recall_semantic(args)
+          query = args["query"]
+          mode = (args["mode"] || "both").to_sym
+          scope = extract_scope(args)
+          limit = extract_limit(args)
+          compact = args["compact"] == true
+          explain = args["explain"] == true
+          intent = extract_intent(args)
+
+          results = @recall.query_semantic(query, limit: limit, scope: scope, mode: mode, explain: explain, intent: intent)
+          ResponseFormatter.format_semantic_results(query, mode.to_s, scope, results, compact: compact)
+        end
+
+        def search_concepts(args)
+          concepts = args["concepts"]
+          scope = extract_scope(args)
+          limit = extract_limit(args)
+          compact = args["compact"] == true
+
+          return {error: "Must provide 2-5 concepts"} unless (2..5).cover?(concepts.size)
+
+          results = @recall.query_concepts(concepts, limit: limit, scope: scope)
+          ResponseFormatter.format_concept_results(concepts, scope, results, compact: compact)
+        end
+
+        def fact_graph(args)
+          fact_id = args["fact_id"]
+          depth = args["depth"] || 2
+          scope = args["scope"] || "project"
+
+          graph = @recall.fact_graph(fact_id, depth: depth, scope: scope)
+
+          return {error: "Fact #{fact_id} not found in #{scope} database"} if graph[:node_count] == 0
+
+          graph
+        end
+
+        def undistilled(args)
+          limit = args["limit"] || 3
+          min_length = args["min_length"] || 200
+          max_text = 2000
+
+          items = collect_undistilled_items(limit: limit, min_length: min_length)
+
+          {
+            count: items.size,
+            items: items.map { |item|
+              {
+                content_item_id: item[:id],
+                occurred_at: item[:occurred_at],
+                occurred_ago: Core::RelativeTime.format(item[:occurred_at]),
+                project_path: item[:project_path],
+                raw_text: Core::TextBuilder.truncate(item[:raw_text], max_text)
+              }
+            }
+          }
+        end
+      end
+    end
+  end
+end

data/lib/claude_memory/mcp/handlers/setup_handlers.rb

@@ -0,0 +1,211 @@
+# frozen_string_literal: true
+
+module ClaudeMemory
+  module MCP
+    module Handlers
+      # Setup and discovery tool handlers
+      module SetupHandlers
+        def check_setup
+          issues = []
+          warnings = []
+          config = Configuration.new
+
+          global_db_exists = check_global_database(config, issues)
+          project_db_exists = check_project_database(config, warnings)
+          current_version, version_status, claude_md_exists = check_claude_md_version(warnings)
+          hooks_configured = check_hooks_configuration(warnings)
+
+          build_setup_result(
+            global_db_exists, project_db_exists, claude_md_exists,
+            hooks_configured, current_version, version_status,
+            issues, warnings
+          )
+        end
+
+        def list_projects
+          result = {global: nil, current_project: nil, other_projects: []}
+
+          if @manager
+            result[:global] = list_global_database
+            result[:current_project] = list_current_project
+            result[:other_projects] = discover_other_projects
+          elsif @legacy_store
+            result[:global] = {
+              exists: true,
+              path: @legacy_store.db.opts[:database],
+              facts_active: @legacy_store.facts.where(status: "active").count,
+              entities: @legacy_store.entities.count
+            }
+          end
+
+          result[:project_count] = 1 + result[:other_projects].size
+          result
+        end
+
+        private
+
+        def check_global_database(config, issues)
+          exists = File.exist?(config.global_db_path)
+          issues << "Global database not found at #{config.global_db_path}" unless exists
+          exists
+        end
+
+        def check_project_database(config, warnings)
+          exists = File.exist?(config.project_db_path)
+          warnings << "Project database not found at #{config.project_db_path}" unless exists
+          exists
+        end
+
+        def check_claude_md_version(warnings)
+          claude_md_path = ".claude/CLAUDE.md"
+          unless File.exist?(claude_md_path)
+            warnings << "No .claude/CLAUDE.md found"
+            return [nil, nil, false]
+          end
+
+          content = File.read(claude_md_path)
+          unless content.include?("ClaudeMemory")
+            warnings << "CLAUDE.md exists but no ClaudeMemory configuration found"
+            return [nil, nil, true]
+          end
+
+          current_version = SetupStatusAnalyzer.extract_version(content)
+          unless current_version
+            warnings << "CLAUDE.md has ClaudeMemory section but no version marker"
+            return [nil, "no_version_marker", true]
+          end
+
+          version_status = SetupStatusAnalyzer.determine_version_status(current_version, ClaudeMemory::VERSION)
+          if version_status == "outdated"
+            warnings << "Configuration version (v#{current_version}) is older than ClaudeMemory (v#{ClaudeMemory::VERSION}). Consider running upgrade."
+          end
+
+          [current_version, version_status, true]
+        end
+
+        def check_hooks_configuration(warnings)
+          settings_paths = [".claude/settings.json", ".claude/settings.local.json"]
+          settings_paths.each do |path|
+            next unless File.exist?(path)
+            begin
+              config_data = JSON.parse(File.read(path))
+              return true if config_data["hooks"]&.any?
+            rescue JSON::ParserError
+              warnings << "Invalid JSON in #{path}"
+            end
+          end
+
+          warnings << "No hooks configured for automatic ingestion"
+          false
+        end
+
+        def build_setup_result(global_db_exists, project_db_exists, claude_md_exists, hooks_configured, current_version, version_status, issues, warnings)
+          initialized = global_db_exists && claude_md_exists
+          status = SetupStatusAnalyzer.determine_status(global_db_exists, claude_md_exists, version_status)
+          recommendations = SetupStatusAnalyzer.generate_recommendations(initialized, version_status, warnings.any?)
+
+          {
+            status: status,
+            initialized: initialized,
+            version: {
+              current: current_version || "unknown",
+              latest: ClaudeMemory::VERSION,
+              status: version_status || "unknown"
+            },
+            components: {
+              global_database: global_db_exists,
+              project_database: project_db_exists,
+              claude_md: claude_md_exists,
+              hooks_configured: hooks_configured
+            },
+            issues: issues,
+            warnings: warnings,
+            recommendations: recommendations
+          }
+        end
+
+        def list_global_database
+          if @manager.global_exists?
+            @manager.ensure_global!
+            store = @manager.global_store
+            {
+              exists: true,
+              path: @manager.global_db_path,
+              facts_active: store.facts.where(status: "active").count,
+              facts_total: store.facts.count,
+              entities: store.entities.count
+            }
+          else
+            {exists: false, path: @manager.global_db_path}
+          end
+        end
+
+        def list_current_project
+          if @manager.project_exists?
+            @manager.ensure_project!
+            store = @manager.project_store
+            {
+              exists: true,
+              path: @manager.project_path,
+              db_path: @manager.project_db_path,
+              facts_active: store.facts.where(status: "active").count,
+              facts_total: store.facts.count,
+              entities: store.entities.count
+            }
+          else
+            {exists: false, path: @manager.project_path, db_path: @manager.project_db_path}
+          end
+        end
+
+        def discover_other_projects
+          return [] unless @manager.global_exists?
+
+          @manager.ensure_global!
+          global = @manager.global_store
+
+          promoted_paths = global.facts
+            .where(Sequel.like(:created_from, "promoted:%"))
+            .select(:created_from)
+            .distinct
+            .all
+            .filter_map { |f|
+              match = f[:created_from]&.match(/\Apromoted:(.+):\d+\z/)
+              match[1] if match
+            }
+            .uniq
+
+          fact_paths = global.facts
+            .exclude(project_path: nil)
+            .select(:project_path)
+            .distinct
+            .all
+            .map { |f| f[:project_path] }
+
+          all_paths = (promoted_paths + fact_paths).uniq
+          current = @manager.project_path
+
+          all_paths.filter_map { |path|
+            next if path == current
+
+            db_path = File.join(path, ".claude", "memory.sqlite3")
+            entry = {path: path, db_path: db_path, exists: File.exist?(db_path)}
+
+            if entry[:exists]
+              begin
+                temp_store = Store::SQLiteStore.new(db_path)
+                entry[:facts_active] = temp_store.facts.where(status: "active").count
+                entry[:facts_total] = temp_store.facts.count
+                entry[:entities] = temp_store.entities.count
+                temp_store.close
+              rescue Sequel::DatabaseError, Extralite::Error, IOError => _e
+                entry[:error] = "Could not read database"
+              end
+            end
+
+            entry
+          }
+        end
+      end
+    end
+  end
+end

data/lib/claude_memory/mcp/handlers/shortcut_handlers.rb

@@ -0,0 +1,37 @@
+# frozen_string_literal: true
+
+module ClaudeMemory
+  module MCP
+    module Handlers
+      # Shortcut tool handlers (decisions, conventions, architecture)
+      module ShortcutHandlers
+        def decisions(args)
+          return {error: "Decisions shortcut requires StoreManager"} unless @manager
+
+          results = Recall.recent_decisions(@manager, limit: args["limit"] || 10)
+          format_shortcut_results(results, "decisions")
+        end
+
+        def conventions(args)
+          return {error: "Conventions shortcut requires StoreManager"} unless @manager
+
+          results = Recall.conventions(@manager, limit: args["limit"] || 20)
+          format_shortcut_results(results, "conventions")
+        end
+
+        def architecture(args)
+          return {error: "Architecture shortcut requires StoreManager"} unless @manager
+
+          results = Recall.architecture_choices(@manager, limit: args["limit"] || 10)
+          format_shortcut_results(results, "architecture")
+        end
+
+        private
+
+        def format_shortcut_results(results, category)
+          ResponseFormatter.format_shortcut_results(category, results)
+        end
+      end
+    end
+  end
+end