claude_memory 0.7.0 → 0.8.0

data/lib/claude_memory/mcp/text_summary.rb

@@ -28,6 +28,8 @@ module ClaudeMemory
         when "memory.recall_semantic" then summarize_semantic(result)
         when "memory.search_concepts" then summarize_concepts(result)
         when "memory.fact_graph" then summarize_fact_graph(result)
+        when "memory.undistilled" then summarize_undistilled(result)
+        when "memory.mark_distilled" then summarize_mark_distilled(result)
         when "memory.check_setup" then summarize_check_setup(result)
         else JSON.generate(result)
         end
@@ -104,7 +106,8 @@ module ClaudeMemory
       end
 
       def self.summarize_sweep(result)
-        "Sweep (#{result[:scope]}): #{result[:proposed_expired]} proposed expired, " \
+        escalation = result[:escalation_level] ? " [#{result[:escalation_level]}]" : ""
+        "Sweep (#{result[:scope]})#{escalation}: #{result[:proposed_expired]} proposed expired, " \
           "#{result[:disputed_expired]} disputed expired, " \
           "#{result[:orphaned_deleted]} orphaned deleted, " \
           "#{result[:content_pruned]} content pruned " \
@@ -121,6 +124,10 @@ module ClaudeMemory
             "- #{name}: #{info[:facts_active]} active facts, #{info[:open_conflicts]} conflicts (schema v#{info[:schema_version]})"
           end
         end
+
+        pending = result[:pending_distillation] || 0
+        lines << "Pending distillation: #{pending}" if pending > 0
+
         lines.join("\n")
       end
 
@@ -232,6 +239,26 @@ module ClaudeMemory
         lines.join("\n")
       end
 
+      def self.summarize_undistilled(result)
+        items = result[:items] || []
+        return "No undistilled content items." if items.empty?
+
+        lines = ["#{result[:count]} undistilled content item(s):"]
+        items.each do |i|
+          ago = i[:occurred_ago] || "unknown"
+          lines << "- Item ##{i[:content_item_id]} (#{ago}): #{(i[:raw_text] || "")[0, 80]}..."
+        end
+        lines.join("\n")
+      end
+
+      def self.summarize_mark_distilled(result)
+        if result[:success]
+          "Marked content item ##{result[:content_item_id]} as distilled (#{result[:facts_extracted]} facts extracted)"
+        else
+          result[:error]
+        end
+      end
+
       def self.summarize_check_setup(result)
         lines = ["Setup status: #{result[:status]}"]
         lines << "Version: #{result[:version][:current]} (latest: #{result[:version][:latest]})"

data/lib/claude_memory/mcp/tool_definitions.rb

@@ -25,6 +25,7 @@ module ClaudeMemory
               type: "object",
               properties: {
                 query: {type: "string", description: "Search query for existing knowledge (e.g., 'authentication flow', 'error handling', 'database setup')"},
+                intent: {type: "string", description: "Optional intent to disambiguate the query (e.g., 'migration' or 'performance' when query is 'database'). Steers search without replacing the query."},
                 limit: {type: "integer", description: "Max results", default: 10},
                 scope: {type: "string", enum: ["all", "global", "project"], description: "Filter by scope: 'all' (default), 'global', or 'project'", default: "all"},
                 compact: {type: "boolean", description: "Omit provenance receipts for ~60% smaller responses (~800 → ~300 tokens/result)", default: false}
@@ -40,6 +41,7 @@ module ClaudeMemory
               type: "object",
               properties: {
                 query: {type: "string", description: "Search query for existing knowledge (e.g., 'client errors', 'database choice')"},
+                intent: {type: "string", description: "Optional intent to disambiguate the query (e.g., 'schema' or 'optimization' when query is 'database'). Steers search without replacing the query."},
                 limit: {type: "integer", description: "Maximum results to return", default: 20},
                 scope: {type: "string", enum: ["all", "global", "project"], description: "Scope: 'all' (both), 'global' (user-wide), 'project' (current only)", default: "all"}
               },
@@ -99,12 +101,13 @@ module ClaudeMemory
           },
           {
             name: "memory.sweep_now",
-            description: "Run maintenance sweep on a database",
+            description: "Run maintenance sweep on a database. Use escalate: true for guaranteed progress (normal → aggressive → fallback).",
             inputSchema: {
               type: "object",
               properties: {
                 budget_seconds: {type: "integer", default: 5},
-                scope: {type: "string", enum: ["global", "project"], default: "project"}
+                scope: {type: "string", enum: ["global", "project"], default: "project"},
+                escalate: {type: "boolean", default: false, description: "Enable three-level escalation (normal → aggressive → fallback) to guarantee progress"}
               }
             },
             annotations: WRITE
@@ -264,10 +267,12 @@ module ClaudeMemory
               type: "object",
               properties: {
                 query: {type: "string", description: "Search query"},
+                intent: {type: "string", description: "Optional intent to disambiguate the query (e.g., 'security' when query is 'authentication'). Disables BM25 shortcut to ensure vector search runs."},
                 mode: {type: "string", enum: ["vector", "text", "both"], default: "both", description: "Search mode: vector (embeddings), text (FTS), or both (hybrid)"},
                 limit: {type: "integer", default: 10, description: "Maximum results to return"},
                 scope: {type: "string", enum: ["all", "global", "project"], default: "all", description: "Filter by scope"},
-                compact: {type: "boolean", description: "Omit provenance receipts for ~60% smaller responses (~800 → ~300 tokens/result)", default: false}
+                compact: {type: "boolean", description: "Omit provenance receipts for ~60% smaller responses (~800 → ~300 tokens/result)", default: false},
+                explain: {type: "boolean", description: "Include per-result score traces showing FTS rank, vector similarity, and RRF contribution", default: false}
               },
               required: ["query"]
             },
@@ -308,6 +313,31 @@ module ClaudeMemory
             },
             annotations: READ_ONLY
           },
+          {
+            name: "memory.undistilled",
+            description: "List content items not yet deeply distilled. Returns raw transcript text for knowledge extraction.",
+            inputSchema: {
+              type: "object",
+              properties: {
+                limit: {type: "integer", default: 3, description: "Max items to return"},
+                min_length: {type: "integer", default: 200, description: "Min text length (skip tiny deltas)"}
+              }
+            },
+            annotations: READ_ONLY
+          },
+          {
+            name: "memory.mark_distilled",
+            description: "Mark a content item as distilled after extracting facts from it.",
+            inputSchema: {
+              type: "object",
+              properties: {
+                content_item_id: {type: "integer", description: "ID of the distilled content item"},
+                facts_extracted: {type: "integer", default: 0, description: "Number of facts extracted"}
+              },
+              required: ["content_item_id"]
+            },
+            annotations: WRITE_IDEMPOTENT
+          },
           {
             name: "memory.check_setup",
             description: "Check ClaudeMemory initialization status. Returns version info, issues found, and recommendations.",

data/lib/claude_memory/mcp/tool_helpers.rb

@@ -75,6 +75,49 @@ module ClaudeMemory
       def extract_limit(args, default: 10)
         args["limit"] || default
       end
+
+      # Extract optional intent parameter for query disambiguation
+      # @param args [Hash] Tool arguments
+      # @return [String, nil] Intent string or nil if not provided/blank
+      def extract_intent(args)
+        intent = args["intent"]
+        (intent.nil? || intent.to_s.strip.empty?) ? nil : intent.to_s.strip
+      end
+
+      # Collect undistilled content items from both stores (or legacy store)
+      # @param limit [Integer] Maximum items to return
+      # @param min_length [Integer] Minimum byte_len to include
+      # @return [Array<Hash>] Undistilled items sorted by recency
+      def collect_undistilled_items(limit:, min_length: 200)
+        if @manager
+          stores = []
+          stores << @manager.project_store if @manager.project_exists?
+          stores << @manager.global_store if @manager.global_exists?
+          items = stores.flat_map { |s| s.undistilled_content_items(limit: limit, min_length: min_length) }
+          items.sort_by { |i| i[:occurred_at] || "" }.reverse.first(limit)
+        elsif @legacy_store
+          @legacy_store.undistilled_content_items(limit: limit, min_length: min_length)
+        else
+          []
+        end
+      end
+
+      # Find the store containing a given content item
+      # @param content_item_id [Integer] Content item ID to locate
+      # @return [Store::SQLiteStore, nil] The store containing the item, or nil
+      def find_store_for_content_item(content_item_id)
+        if @manager
+          if @manager.project_store&.content_items&.where(id: content_item_id)&.any?
+            @manager.project_store
+          elsif @manager.global_store&.content_items&.where(id: content_item_id)&.any?
+            @manager.global_store
+          end
+        elsif @legacy_store
+          if @legacy_store.content_items.where(id: content_item_id).any?
+            @legacy_store
+          end
+        end
+      end
     end
   end
 end