claude_memory 0.1.0 → 0.2.0

data/lib/claude_memory/recall.rb

@@ -6,6 +6,24 @@ module ClaudeMemory
     SCOPE_GLOBAL = "global"
     SCOPE_ALL = "all"
 
+    class << self
+      def recent_decisions(manager, limit: 10)
+        Shortcuts.for(:decisions, manager, limit: limit)
+      end
+
+      def architecture_choices(manager, limit: 10)
+        Shortcuts.for(:architecture, manager, limit: limit)
+      end
+
+      def conventions(manager, limit: 20)
+        Shortcuts.for(:conventions, manager, limit: limit)
+      end
+
+      def project_config(manager, limit: 10)
+        Shortcuts.for(:project_config, manager, limit: limit)
+      end
+    end
+
     def initialize(store_or_manager, fts: nil, project_path: nil, env: ENV)
       @project_path = project_path || env["CLAUDE_PROJECT_DIR"] || Dir.pwd
 
@@ -27,6 +45,14 @@ module ClaudeMemory
       end
     end
 
+    def query_index(query_text, limit: 20, scope: SCOPE_ALL)
+      if @legacy_mode
+        query_index_legacy(query_text, limit: limit, scope: scope)
+      else
+        query_index_dual(query_text, limit: limit, scope: scope)
+      end
+    end
+
     def explain(fact_id, scope: nil)
       if @legacy_mode
         explain_from_store(@legacy_store, fact_id)
@@ -77,38 +103,141 @@ module ClaudeMemory
       dedupe_and_sort(results, limit)
     end
 
+    def query_index_dual(query_text, limit:, scope:)
+      results = []
+
+      if scope == SCOPE_ALL || scope == SCOPE_PROJECT
+        @manager.ensure_project! if @manager.project_exists?
+        if @manager.project_store
+          project_results = query_index_single_store(@manager.project_store, query_text, limit: limit, source: :project)
+          results.concat(project_results)
+        end
+      end
+
+      if scope == SCOPE_ALL || scope == SCOPE_GLOBAL
+        @manager.ensure_global! if @manager.global_exists?
+        if @manager.global_store
+          global_results = query_index_single_store(@manager.global_store, query_text, limit: limit, source: :global)
+          results.concat(global_results)
+        end
+      end
+
+      dedupe_and_sort_index(results, limit)
+    end
+
+    def query_index_single_store(store, query_text, limit:, source:)
+      options = Index::QueryOptions.new(
+        query_text: query_text,
+        limit: limit,
+        scope: :all,
+        source: source
+      )
+
+      query = Index::IndexQuery.new(store, options)
+      query.execute
+    end
+
+    def dedupe_and_sort_index(results, limit)
+      seen_signatures = Set.new
+      unique_results = []
+
+      results.each do |result|
+        sig = "#{result[:subject]}:#{result[:predicate]}:#{result[:object_preview]}"
+        next if seen_signatures.include?(sig)
+
+        seen_signatures.add(sig)
+        unique_results << result
+      end
+
+      # Sort by source priority (project first)
+      unique_results.sort_by do |item|
+        source_priority = (item[:source] == :project) ? 0 : 1
+        [source_priority]
+      end.first(limit)
+    end
+
     def query_single_store(store, query_text, limit:, source:)
       fts = Index::LexicalFTS.new(store)
       content_ids = fts.search(query_text, limit: limit * 3)
       return [] if content_ids.empty?
 
-      facts_with_provenance = []
+      # Collect all fact_ids first
       seen_fact_ids = Set.new
+      ordered_fact_ids = []
 
       content_ids.each do |content_id|
         provenance_records = store.provenance
-          .select(:id, :fact_id, :content_item_id, :quote, :strength)
+          .select(:fact_id)
           .where(content_item_id: content_id)
           .all
 
         provenance_records.each do |prov|
-          next if seen_fact_ids.include?(prov[:fact_id])
+          fact_id = prov[:fact_id]
+          next if seen_fact_ids.include?(fact_id)
 
-          fact = find_fact_from_store(store, prov[:fact_id])
-          next unless fact
-
-          seen_fact_ids.add(prov[:fact_id])
-          facts_with_provenance << {
-            fact: fact,
-            receipts: find_receipts_from_store(store, prov[:fact_id]),
-            source: source
-          }
-          break if facts_with_provenance.size >= limit
+          seen_fact_ids.add(fact_id)
+          ordered_fact_ids << fact_id
+          break if ordered_fact_ids.size >= limit
         end
-        break if facts_with_provenance.size >= limit
+        break if ordered_fact_ids.size >= limit
       end
 
-      facts_with_provenance
+      return [] if ordered_fact_ids.empty?
+
+      # Batch query all facts at once
+      facts_by_id = batch_find_facts(store, ordered_fact_ids)
+
+      # Batch query all receipts at once
+      receipts_by_fact_id = batch_find_receipts(store, ordered_fact_ids)
+
+      # Build results maintaining order
+      ordered_fact_ids.map do |fact_id|
+        fact = facts_by_id[fact_id]
+        next unless fact
+
+        {
+          fact: fact,
+          receipts: receipts_by_fact_id[fact_id] || [],
+          source: source
+        }
+      end.compact
+    end
+
+    def batch_find_facts(store, fact_ids)
+      store.facts
+        .left_join(:entities, id: :subject_entity_id)
+        .select(
+          Sequel[:facts][:id],
+          Sequel[:facts][:predicate],
+          Sequel[:facts][:object_literal],
+          Sequel[:facts][:status],
+          Sequel[:facts][:confidence],
+          Sequel[:facts][:valid_from],
+          Sequel[:facts][:valid_to],
+          Sequel[:facts][:created_at],
+          Sequel[:entities][:canonical_name].as(:subject_name),
+          Sequel[:facts][:scope],
+          Sequel[:facts][:project_path]
+        )
+        .where(Sequel[:facts][:id] => fact_ids)
+        .all
+        .each_with_object({}) { |fact, hash| hash[fact[:id]] = fact }
+    end
+
+    def batch_find_receipts(store, fact_ids)
+      store.provenance
+        .left_join(:content_items, id: :content_item_id)
+        .select(
+          Sequel[:provenance][:id],
+          Sequel[:provenance][:fact_id],
+          Sequel[:provenance][:quote],
+          Sequel[:provenance][:strength],
+          Sequel[:content_items][:session_id],
+          Sequel[:content_items][:occurred_at]
+        )
+        .where(Sequel[:provenance][:fact_id] => fact_ids)
+        .all
+        .group_by { |receipt| receipt[:fact_id] }
     end
 
     def dedupe_and_sort(results, limit)
@@ -189,7 +318,7 @@ module ClaudeMemory
 
     def explain_from_store(store, fact_id)
       fact = find_fact_from_store(store, fact_id)
-      return nil unless fact
+      return Core::NullExplanation.new unless fact
 
       {
         fact: fact,
@@ -282,6 +411,25 @@ module ClaudeMemory
       sort_by_scope_priority(facts_with_provenance)
     end
 
+    def query_index_legacy(query_text, limit:, scope:)
+      options = Index::QueryOptions.new(
+        query_text: query_text,
+        limit: limit,
+        scope: :all,
+        source: :legacy
+      )
+
+      query = Index::IndexQuery.new(@legacy_store, options)
+      results = query.execute
+
+      # Filter by scope in legacy mode
+      results.select do |result|
+        # Need to get full fact to check scope
+        fact = find_fact(result[:id])
+        fact && fact_matches_scope?(fact, scope)
+      end
+    end
+
     def changes_legacy(since:, limit:, scope:)
       ds = @legacy_store.facts
         .select(:id, :subject_entity_id, :predicate, :object_literal, :status, :created_at, :scope, :project_path)

data/lib/claude_memory/resolve/resolver.rb

@@ -57,48 +57,51 @@ module ClaudeMemory
 
         existing_facts = @store.facts_for_slot(subject_id, predicate)
 
-        if PredicatePolicy.single?(predicate) && existing_facts.any?
-          matching = existing_facts.find { |f| values_match?(f, object_val, object_entity_id) }
-          if matching
-            add_provenance(matching[:id], content_item_id, fact_data)
-            outcome[:provenance] = 1
-            return outcome
-          elsif supersession_signal?(fact_data)
-            supersede_facts(existing_facts, occurred_at)
-            outcome[:superseded] = existing_facts.size
-          else
-            create_conflict(existing_facts.first[:id], fact_data, subject_id, content_item_id, occurred_at)
-            outcome[:conflicts] = 1
-            return outcome
+        # Wrap all database operations in a transaction for atomicity
+        @store.db.transaction do
+          if PredicatePolicy.single?(predicate) && existing_facts.any?
+            matching = existing_facts.find { |f| values_match?(f, object_val, object_entity_id) }
+            if matching
+              add_provenance(matching[:id], content_item_id, fact_data)
+              outcome[:provenance] = 1
+              return outcome
+            elsif supersession_signal?(fact_data)
+              supersede_facts(existing_facts, occurred_at)
+              outcome[:superseded] = existing_facts.size
+            else
+              create_conflict(existing_facts.first[:id], fact_data, subject_id, content_item_id, occurred_at)
+              outcome[:conflicts] = 1
+              return outcome
+            end
           end
-        end
-
-        fact_scope = fact_data[:scope_hint] || @current_scope
-        fact_project = (fact_scope == "global") ? nil : @current_project_path
-
-        fact_id = @store.insert_fact(
-          subject_entity_id: subject_id,
-          predicate: predicate,
-          object_entity_id: object_entity_id,
-          object_literal: object_val,
-          polarity: fact_data[:polarity] || "positive",
-          confidence: fact_data[:confidence] || 1.0,
-          valid_from: occurred_at,
-          scope: fact_scope,
-          project_path: fact_project
-        )
-        outcome[:created] = 1
 
-        if existing_facts.any? && outcome[:superseded] > 0
-          existing_facts.each do |old_fact|
-            @store.insert_fact_link(from_fact_id: fact_id, to_fact_id: old_fact[:id], link_type: "supersedes")
+          fact_scope = fact_data[:scope_hint] || @current_scope
+          fact_project = (fact_scope == "global") ? nil : @current_project_path
+
+          fact_id = @store.insert_fact(
+            subject_entity_id: subject_id,
+            predicate: predicate,
+            object_entity_id: object_entity_id,
+            object_literal: object_val,
+            polarity: fact_data[:polarity] || "positive",
+            confidence: fact_data[:confidence] || 1.0,
+            valid_from: occurred_at,
+            scope: fact_scope,
+            project_path: fact_project
+          )
+          outcome[:created] = 1
+
+          if existing_facts.any? && outcome[:superseded] > 0
+            existing_facts.each do |old_fact|
+              @store.insert_fact_link(from_fact_id: fact_id, to_fact_id: old_fact[:id], link_type: "supersedes")
+            end
           end
-        end
 
-        add_provenance(fact_id, content_item_id, fact_data)
-        outcome[:provenance] = 1
+          add_provenance(fact_id, content_item_id, fact_data)
+          outcome[:provenance] = 1
 
-        outcome
+          outcome
+        end
       end
 
       def supersession_signal?(fact_data)
@@ -118,6 +121,7 @@ module ClaudeMemory
       end
 
       def create_conflict(existing_fact_id, new_fact_data, subject_id, content_item_id, occurred_at)
+        # Already within transaction from resolve_fact
         new_fact_id = @store.insert_fact(
           subject_entity_id: subject_id,
           predicate: new_fact_data[:predicate],

data/lib/claude_memory/shortcuts.rb

@@ -0,0 +1,56 @@
+# frozen_string_literal: true
+
+module ClaudeMemory
+  class Shortcuts
+    QUERIES = {
+      decisions: {
+        query: "decision constraint rule requirement",
+        scope: :all,
+        limit: 10
+      },
+      architecture: {
+        query: "uses framework implements architecture pattern",
+        scope: :all,
+        limit: 10
+      },
+      conventions: {
+        query: "convention style format pattern prefer",
+        scope: :global,
+        limit: 20
+      },
+      project_config: {
+        query: "uses requires depends_on configuration",
+        scope: :project,
+        limit: 10
+      }
+    }.freeze
+
+    def self.for(shortcut_name, manager, **overrides)
+      config = QUERIES.fetch(shortcut_name)
+      options = config.merge(overrides)
+
+      recall = Recall.new(manager)
+      recall.query(
+        options[:query],
+        limit: options[:limit],
+        scope: options[:scope]
+      )
+    end
+
+    def self.decisions(manager, **overrides)
+      self.for(:decisions, manager, **overrides)
+    end
+
+    def self.architecture(manager, **overrides)
+      self.for(:architecture, manager, **overrides)
+    end
+
+    def self.conventions(manager, **overrides)
+      self.for(:conventions, manager, **overrides)
+    end
+
+    def self.project_config(manager, **overrides)
+      self.for(:project_config, manager, **overrides)
+    end
+  end
+end

data/lib/claude_memory/store/store_manager.rb

@@ -85,40 +85,43 @@ module ClaudeMemory
         subject = @project_store.entities.where(id: fact[:subject_entity_id]).first
         return nil unless subject
 
-        global_subject_id = @global_store.find_or_create_entity(
-          type: subject[:type],
-          name: subject[:canonical_name]
-        )
-
-        global_object_id = nil
-        if fact[:object_entity_id]
-          object = @project_store.entities.where(id: fact[:object_entity_id]).first
-          if object
-            global_object_id = @global_store.find_or_create_entity(
-              type: object[:type],
-              name: object[:canonical_name]
-            )
+        # Wrap all database operations in a transaction for atomicity
+        @global_store.db.transaction do
+          global_subject_id = @global_store.find_or_create_entity(
+            type: subject[:type],
+            name: subject[:canonical_name]
+          )
+
+          global_object_id = nil
+          if fact[:object_entity_id]
+            object = @project_store.entities.where(id: fact[:object_entity_id]).first
+            if object
+              global_object_id = @global_store.find_or_create_entity(
+                type: object[:type],
+                name: object[:canonical_name]
+              )
+            end
           end
-        end
 
-        global_fact_id = @global_store.insert_fact(
-          subject_entity_id: global_subject_id,
-          predicate: fact[:predicate],
-          object_entity_id: global_object_id,
-          object_literal: fact[:object_literal],
-          datatype: fact[:datatype],
-          polarity: fact[:polarity],
-          valid_from: fact[:valid_from],
-          status: fact[:status],
-          confidence: fact[:confidence],
-          created_from: "promoted:#{@project_path}:#{fact_id}",
-          scope: "global",
-          project_path: nil
-        )
-
-        copy_provenance(fact_id, global_fact_id)
-
-        global_fact_id
+          global_fact_id = @global_store.insert_fact(
+            subject_entity_id: global_subject_id,
+            predicate: fact[:predicate],
+            object_entity_id: global_object_id,
+            object_literal: fact[:object_literal],
+            datatype: fact[:datatype],
+            polarity: fact[:polarity],
+            valid_from: fact[:valid_from],
+            status: fact[:status],
+            confidence: fact[:confidence],
+            created_from: "promoted:#{@project_path}:#{fact_id}",
+            scope: "global",
+            project_path: nil
+          )
+
+          copy_provenance(fact_id, global_fact_id)
+
+          global_fact_id
+        end
       end
 
       private

data/lib/claude_memory/templates/hooks.example.json

@@ -2,7 +2,6 @@
   "hooks": {
     "Stop": [
       {
-        "matcher": "",
         "hooks": [
           {
             "type": "command",
@@ -14,7 +13,6 @@
     ],
     "SessionStart": [
       {
-        "matcher": "",
         "hooks": [
           {
             "type": "command",
@@ -26,7 +24,6 @@
     ],
     "PreCompact": [
       {
-        "matcher": "",
         "hooks": [
           {
             "type": "command",
@@ -43,7 +40,6 @@
     ],
     "SessionEnd": [
       {
-        "matcher": "",
         "hooks": [
           {
             "type": "command",

data/lib/claude_memory/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module ClaudeMemory
-  VERSION = "0.1.0"
+  VERSION = "0.2.0"
 end

data/lib/claude_memory.rb

@@ -2,10 +2,67 @@
 
 module ClaudeMemory
   class Error < StandardError; end
+end
 
-  LEGACY_DB_PATH = ".claude_memory.sqlite3"
-  PROJECT_DB_PATH = ".claude/memory.sqlite3"
+require_relative "claude_memory/core/result"
+require_relative "claude_memory/core/session_id"
+require_relative "claude_memory/core/transcript_path"
+require_relative "claude_memory/core/fact_id"
+require_relative "claude_memory/core/null_fact"
+require_relative "claude_memory/core/null_explanation"
+require_relative "claude_memory/core/token_estimator"
+require_relative "claude_memory/commands/base_command"
+require_relative "claude_memory/commands/help_command"
+require_relative "claude_memory/commands/version_command"
+require_relative "claude_memory/commands/doctor_command"
+require_relative "claude_memory/commands/promote_command"
+require_relative "claude_memory/commands/search_command"
+require_relative "claude_memory/commands/explain_command"
+require_relative "claude_memory/commands/conflicts_command"
+require_relative "claude_memory/commands/changes_command"
+require_relative "claude_memory/commands/recall_command"
+require_relative "claude_memory/commands/sweep_command"
+require_relative "claude_memory/commands/ingest_command"
+require_relative "claude_memory/commands/publish_command"
+require_relative "claude_memory/commands/db_init_command"
+require_relative "claude_memory/commands/init_command"
+require_relative "claude_memory/commands/serve_mcp_command"
+require_relative "claude_memory/commands/hook_command"
+require_relative "claude_memory/commands/registry"
+require_relative "claude_memory/cli"
+require_relative "claude_memory/configuration"
+require_relative "claude_memory/distill/distiller"
+require_relative "claude_memory/distill/extraction"
+require_relative "claude_memory/distill/null_distiller"
+require_relative "claude_memory/domain/fact"
+require_relative "claude_memory/domain/entity"
+require_relative "claude_memory/domain/provenance"
+require_relative "claude_memory/domain/conflict"
+require_relative "claude_memory/hook/exit_codes"
+require_relative "claude_memory/hook/handler"
+require_relative "claude_memory/index/query_options"
+require_relative "claude_memory/index/index_query_logic"
+require_relative "claude_memory/index/index_query"
+require_relative "claude_memory/index/lexical_fts"
+require_relative "claude_memory/ingest/privacy_tag"
+require_relative "claude_memory/ingest/content_sanitizer"
+require_relative "claude_memory/ingest/ingester"
+require_relative "claude_memory/ingest/transcript_reader"
+require_relative "claude_memory/infrastructure/file_system"
+require_relative "claude_memory/infrastructure/in_memory_file_system"
+require_relative "claude_memory/mcp/server"
+require_relative "claude_memory/mcp/tools"
+require_relative "claude_memory/publish"
+require_relative "claude_memory/recall"
+require_relative "claude_memory/shortcuts"
+require_relative "claude_memory/resolve/predicate_policy"
+require_relative "claude_memory/resolve/resolver"
+require_relative "claude_memory/store/sqlite_store"
+require_relative "claude_memory/store/store_manager"
+require_relative "claude_memory/sweep/sweeper"
+require_relative "claude_memory/version"
 
+module ClaudeMemory
   def self.global_db_path(env = ENV)
     home = env["HOME"] || File.expand_path("~")
     File.join(home, ".claude", "memory.sqlite3")
@@ -15,22 +72,3 @@ module ClaudeMemory
     File.join(project_path, ".claude", "memory.sqlite3")
   end
 end
-
-require_relative "claude_memory/version"
-require_relative "claude_memory/cli"
-require_relative "claude_memory/store/sqlite_store"
-require_relative "claude_memory/store/store_manager"
-require_relative "claude_memory/ingest/transcript_reader"
-require_relative "claude_memory/ingest/ingester"
-require_relative "claude_memory/index/lexical_fts"
-require_relative "claude_memory/distill/extraction"
-require_relative "claude_memory/distill/distiller"
-require_relative "claude_memory/distill/null_distiller"
-require_relative "claude_memory/resolve/predicate_policy"
-require_relative "claude_memory/resolve/resolver"
-require_relative "claude_memory/recall"
-require_relative "claude_memory/sweep/sweeper"
-require_relative "claude_memory/mcp/tools"
-require_relative "claude_memory/mcp/server"
-require_relative "claude_memory/publish"
-require_relative "claude_memory/hook/handler"