claude_memory 0.7.1 → 0.9.0

data/lib/claude_memory/publish.rb

@@ -4,15 +4,22 @@ require "digest"
 require "fileutils"
 
 module ClaudeMemory
+  # Generates Markdown snapshots from active facts for use as project memory.
+  # Publishes to .claude/rules/ (shared), a local file, or the home directory.
   class Publish
     RULES_DIR = ".claude/rules"
     GENERATED_FILE = "claude_memory.generated.md"
 
+    # @param store [Store::SQLiteStore] database store for reading facts
+    # @param file_system [Infrastructure::FileSystem] filesystem abstraction for I/O
     def initialize(store, file_system: Infrastructure::FileSystem.new)
       @store = store
       @fs = file_system
     end
 
+    # Generate a complete Markdown snapshot with header and body
+    # @param since [String, nil] ISO 8601 timestamp to include recent supersessions
+    # @return [String] full Markdown document
     def generate_snapshot(since: nil)
       header = <<~HEADER
         <!--
@@ -28,6 +35,12 @@ module ClaudeMemory
       header + generate_body(since: since)
     end
 
+    # Write snapshot to disk if content has changed
+    # @param mode [Symbol] output target (:shared, :local, or :home)
+    # @param granularity [Symbol] snapshot granularity (currently only :repo)
+    # @param since [String, nil] ISO 8601 timestamp for recent supersessions
+    # @param rules_dir [String, nil] override rules directory path
+    # @return [Hash] result with :status (:updated or :unchanged) and :path
     def publish!(mode: :shared, granularity: :repo, since: nil, rules_dir: nil)
       path = output_path(mode, rules_dir: rules_dir)
       body = generate_body(since: since)
@@ -97,8 +110,9 @@ module ClaudeMemory
         .all
     end
 
+    # @return [String] Markdown section for decision facts
     def generate_decisions_section(facts)
-      decisions = facts.select { |f| f[:predicate] == "decision" || f[:predicate]&.start_with?("decided_") }
+      decisions = facts.select { |f| Resolve::PredicatePolicy.section_for(f[:predicate]) == :decisions }
       return "" if decisions.empty?
 
       lines = ["## Current Decisions\n"]
@@ -108,8 +122,9 @@ module ClaudeMemory
       lines.join("\n") + "\n"
     end
 
+    # @return [String] Markdown section for convention facts
     def generate_conventions_section(facts)
-      conventions = facts.select { |f| f[:predicate] == "convention" || f[:predicate]&.include?("_convention") }
+      conventions = facts.select { |f| Resolve::PredicatePolicy.section_for(f[:predicate]) == :conventions }
       return "" if conventions.empty?
 
       lines = ["## Conventions\n"]
@@ -119,10 +134,9 @@ module ClaudeMemory
       lines.join("\n") + "\n"
     end
 
+    # @return [String] Markdown section for technical constraint facts
     def generate_constraints_section(facts)
-      constraints = facts.select do |f|
-        %w[uses_database uses_framework deployment_platform auth_method].include?(f[:predicate])
-      end
+      constraints = facts.select { |f| Resolve::PredicatePolicy.section_for(f[:predicate]) == :constraints }
       return "" if constraints.empty?
 
       lines = ["## Technical Constraints\n"]
@@ -132,6 +146,25 @@ module ClaudeMemory
       lines.join("\n") + "\n"
     end
 
+    # @return [String] Markdown section for additional knowledge grouped by predicate
+    def generate_additional_section(facts)
+      additional = facts.select { |f| Resolve::PredicatePolicy.section_for(f[:predicate]) == :additional }
+      return "" if additional.empty?
+
+      grouped = additional.group_by { |f| f[:predicate] }
+      lines = ["## Additional Knowledge\n"]
+      grouped.each do |predicate, group_facts|
+        lines << "### #{humanize(predicate)}\n"
+        group_facts.each do |f|
+          subject = f[:subject_name] || "repo"
+          lines << "- #{subject}: #{f[:object_literal]}"
+        end
+        lines << ""
+      end
+      lines.join("\n") + "\n"
+    end
+
+    # @return [String] Markdown section for open conflicts
     def generate_conflicts_section(conflicts)
       return "" if conflicts.empty?
 
@@ -143,6 +176,7 @@ module ClaudeMemory
       lines.join("\n") + "\n"
     end
 
+    # @return [String] Markdown section for recently superseded facts
     def generate_supersessions_section(supersessions)
       return "" if supersessions.empty?
 
@@ -162,6 +196,7 @@ module ClaudeMemory
       sections << generate_decisions_section(facts)
       sections << generate_conventions_section(facts)
       sections << generate_constraints_section(facts)
+      sections << generate_additional_section(facts)
       sections << generate_conflicts_section(conflicts) if conflicts.any?
       sections << generate_supersessions_section(recent_supersessions) if recent_supersessions.any?
 

data/lib/claude_memory/recall/dual_engine.rb

@@ -0,0 +1,105 @@
+# frozen_string_literal: true
+
+module ClaudeMemory
+  class Recall
+    # Query engine for dual-database mode (StoreManager with global + project DBs).
+    # Wraps DualQueryTemplate around shared QueryCore methods.
+    class DualEngine
+      include QueryCore
+
+      def initialize(manager, embedding_generator:, project_path:)
+        @manager = manager
+        @embedding_generator = embedding_generator
+        @project_path = project_path
+      end
+
+      def query(query_text, limit:, scope:, include_raw_text: false, intent: nil)
+        effective_query = intent_augmented_query(query_text, intent)
+        results = dual_execute(scope: scope, limit: limit) do |store, source|
+          query_single_store(store, effective_query, limit: limit, source: source, include_raw_text: include_raw_text)
+        end
+        dedupe_and_sort(results, limit)
+      end
+
+      def query_index(query_text, limit:, scope:, intent: nil)
+        effective_query = intent_augmented_query(query_text, intent)
+        results = dual_execute(scope: scope, limit: limit) do |store, source|
+          query_index_single_store(store, effective_query, limit: limit, source: source)
+        end
+        dedupe_and_sort_index(results, limit)
+      end
+
+      def fact_graph(fact_id, depth:, scope:)
+        scope ||= SCOPE_PROJECT
+        store = @manager.store_for_scope(scope)
+        Core::FactGraph.build(store, fact_id, depth: depth)
+      end
+
+      def explain(fact_id_or_docid, scope:)
+        scope ||= SCOPE_PROJECT
+        store = @manager.store_for_scope(scope)
+        fact_id = resolve_fact_identifier(store, fact_id_or_docid)
+        explain_from_store(store, fact_id)
+      end
+
+      def changes(since:, limit:, scope:)
+        results = dual_execute(scope: scope, limit: limit) do |store, source|
+          changes = fetch_changes(store, since, limit)
+          Core::ResultSorter.annotate_source(changes, source)
+        end
+        Core::ResultSorter.sort_by_timestamp(results, limit)
+      end
+
+      def conflicts(scope:)
+        dual_execute(scope: scope) do |store, source|
+          conflicts = store.open_conflicts
+          Core::ResultSorter.annotate_source(conflicts, source)
+        end
+      end
+
+      def facts_by_branch(branch_name, limit:, scope:)
+        results = dual_execute(scope: scope, limit: limit) do |store, source|
+          facts_by_context_single(store, :git_branch, branch_name, limit: limit, source: source)
+        end
+        dedupe_and_sort(results, limit)
+      end
+
+      def facts_by_directory(cwd, limit:, scope:)
+        results = dual_execute(scope: scope, limit: limit) do |store, source|
+          facts_by_context_single(store, :cwd, cwd, limit: limit, source: source)
+        end
+        dedupe_and_sort(results, limit)
+      end
+
+      def facts_by_tool(tool_name, limit:, scope:)
+        results = dual_execute(scope: scope, limit: limit) do |store, source|
+          facts_by_tool_single(store, tool_name, limit: limit, source: source)
+        end
+        dedupe_and_sort(results, limit)
+      end
+
+      def query_semantic(text, limit:, scope:, mode:, explain: false, intent: nil)
+        effective_text = intent_augmented_query(text, intent)
+        results = dual_execute(scope: scope, limit: limit) do |store, source|
+          query_semantic_single(store, effective_text, limit: limit * 3, mode: mode, source: source, explain: explain,
+            skip_fts_shortcut: !intent.nil?)
+        end
+        dedupe_by_fact_id(results, limit)
+      end
+
+      def query_concepts(concepts, limit:, scope:)
+        results = dual_execute(scope: scope, limit: limit) do |store, source|
+          query_concepts_single(store, concepts, limit: limit * 2, source: source)
+        end
+        dedupe_by_fact_id(results, limit)
+      end
+
+      private
+
+      def dual_execute(scope:, limit: nil, &operation)
+        template = DualQueryTemplate.new(@manager)
+        template.execute(scope: scope, limit: limit, &operation)
+      end
+    end
+  end
+end

data/lib/claude_memory/recall/legacy_engine.rb

@@ -0,0 +1,138 @@
+# frozen_string_literal: true
+
+module ClaudeMemory
+  class Recall
+    # Query engine for legacy single-store mode.
+    # Operates directly on one SQLiteStore with local scope filtering.
+    class LegacyEngine
+      include QueryCore
+
+      def initialize(store, fts:, embedding_generator:, project_path:)
+        @store = store
+        @fts = fts
+        @embedding_generator = embedding_generator
+        @project_path = project_path
+      end
+
+      def query(query_text, limit:, scope:, include_raw_text: false, intent: nil)
+        effective_query = intent_augmented_query(query_text, intent)
+        content_ids = @fts.search(effective_query, limit: limit * 3)
+        return [] if content_ids.empty?
+
+        provenance_by_content = @store.provenance
+          .select(:fact_id, :content_item_id)
+          .where(content_item_id: content_ids)
+          .all
+          .group_by { |p| p[:content_item_id] }
+
+        all_fact_ids = []
+        seen_fact_ids = Set.new
+        content_ids.each do |content_id|
+          (provenance_by_content[content_id] || []).each do |prov|
+            next if seen_fact_ids.include?(prov[:fact_id])
+            seen_fact_ids.add(prov[:fact_id])
+            all_fact_ids << prov[:fact_id]
+          end
+        end
+
+        return [] if all_fact_ids.empty?
+
+        facts_by_id = batch_find_facts(@store, all_fact_ids)
+
+        selected_fact_ids = []
+        all_fact_ids.each do |fact_id|
+          fact = facts_by_id[fact_id]
+          next unless fact
+          next unless fact_matches_scope?(fact, scope)
+          selected_fact_ids << fact_id
+          break if selected_fact_ids.size >= limit
+        end
+
+        return [] if selected_fact_ids.empty?
+
+        receipts_by_fact_id = batch_find_receipts(@store, selected_fact_ids)
+
+        facts_with_provenance = selected_fact_ids.map do |fact_id|
+          {
+            fact: facts_by_id[fact_id],
+            receipts: receipts_by_fact_id[fact_id] || []
+          }
+        end
+
+        sort_by_scope_priority(facts_with_provenance)
+      end
+
+      def query_index(query_text, limit:, scope:, intent: nil)
+        effective_query = intent_augmented_query(query_text, intent)
+        options = Index::QueryOptions.new(
+          query_text: effective_query,
+          limit: limit,
+          scope: :all,
+          source: :legacy
+        )
+
+        query = Index::IndexQuery.new(@store, options)
+        results = query.execute
+
+        results.select do |result|
+          fact = Core::FactQueryBuilder.find_fact(@store, result[:id])
+          fact && fact_matches_scope?(fact, scope)
+        end
+      end
+
+      def fact_graph(fact_id, depth:, scope:)
+        Core::FactGraph.build(@store, fact_id, depth: depth)
+      end
+
+      def explain(fact_id_or_docid, scope:)
+        fact_id = resolve_fact_identifier(@store, fact_id_or_docid)
+        explain_from_store(@store, fact_id)
+      end
+
+      def changes(since:, limit:, scope:)
+        ds = @store.facts
+          .select(:id, :docid, :subject_entity_id, :predicate, :object_literal, :status, :created_at, :scope, :project_path)
+          .where { created_at >= since }
+          .order(Sequel.desc(:created_at))
+          .limit(limit)
+
+        ds = apply_scope_filter(ds, scope)
+        ds.all
+      end
+
+      def conflicts(scope:)
+        all_conflicts = @store.open_conflicts
+        return all_conflicts if scope == SCOPE_ALL
+
+        all_conflicts.select do |conflict|
+          fact_a = Core::FactQueryBuilder.find_fact(@store, conflict[:fact_a_id])
+          fact_b = Core::FactQueryBuilder.find_fact(@store, conflict[:fact_b_id])
+
+          fact_matches_scope?(fact_a, scope) || fact_matches_scope?(fact_b, scope)
+        end
+      end
+
+      def facts_by_branch(branch_name, limit:, scope:)
+        facts_by_context_single(@store, :git_branch, branch_name, limit: limit, source: :legacy)
+      end
+
+      def facts_by_directory(cwd, limit:, scope:)
+        facts_by_context_single(@store, :cwd, cwd, limit: limit, source: :legacy)
+      end
+
+      def facts_by_tool(tool_name, limit:, scope:)
+        facts_by_tool_single(@store, tool_name, limit: limit, source: :legacy)
+      end
+
+      def query_semantic(text, limit:, scope:, mode:, explain: false, intent: nil)
+        effective_text = intent_augmented_query(text, intent)
+        query_semantic_single(@store, effective_text, limit: limit, mode: mode, source: :legacy, explain: explain,
+          skip_fts_shortcut: !intent.nil?)
+      end
+
+      def query_concepts(concepts, limit:, scope:)
+        query_concepts_single(@store, concepts, limit: limit, source: :legacy)
+      end
+    end
+  end
+end