Class: ClaudeMemory::Store::StoreManager

Inherits:
Object
  • Object
show all
Defined in:
lib/claude_memory/store/store_manager.rb

Overview

Dual-database connection manager for global and project stores. Lazily opens SQLiteStore connections to the global database (~/.claude/memory.sqlite3) and the project database (.claude/memory.sqlite3 under the project root). Commands query both databases by default, with project facts taking precedence.

Instance Attribute Summary collapse

Class Method Summary collapse

Instance Method Summary collapse

Constructor Details

#initialize(global_db_path: nil, project_db_path: nil, project_path: nil, env: ENV) ⇒ StoreManager

Returns a new instance of StoreManager.

Parameters:

  • global_db_path (String, nil) (defaults to: nil) —

    override path to the global database

  • project_db_path (String, nil) (defaults to: nil) —

    override path to the project database

  • project_path (String, nil) (defaults to: nil) —

    project directory (defaults to Configuration)

  • env (Hash) (defaults to: ENV) —

    environment variable hash (default: ENV)



26
27
28
29
30
31
32
33
34
 
# File 'lib/claude_memory/store/store_manager.rb', line 26

def initialize(global_db_path: nil, project_db_path: nil, project_path: nil, env: ENV)
  config = Configuration.new(env)
  @project_path = project_path || config.project_dir
  @global_db_path = global_db_path || config.global_db_path
  @project_db_path = project_db_path || config.project_db_path(@project_path)

  @global_store = nil
  @project_store = nil
end

Instance Attribute Details

#global_db_path ⇒ String (readonly)

Returns filesystem path to the global database.

Returns:

  • (String) —

    filesystem path to the global database



78
79
80
 
# File 'lib/claude_memory/store/store_manager.rb', line 78

def global_db_path
  @global_db_path
end

#global_store ⇒ SQLiteStore? (readonly)

Returns global store (nil until #ensure_global! is called).

Returns:



14
15
16
 
# File 'lib/claude_memory/store/store_manager.rb', line 14

def global_store
  @global_store
end

#project_db_path ⇒ String (readonly)

Returns filesystem path to the project database.

Returns:

  • (String) —

    filesystem path to the project database



81
82
83
 
# File 'lib/claude_memory/store/store_manager.rb', line 81

def project_db_path
  @project_db_path
end

#project_path ⇒ String (readonly)

Returns project directory path.

Returns:

  • (String) —

    project directory path



20
21
22
 
# File 'lib/claude_memory/store/store_manager.rb', line 20

def project_path
  @project_path
end

#project_store ⇒ SQLiteStore? (readonly)

Returns project store (nil until #ensure_project! is called).

Returns:



17
18
19
 
# File 'lib/claude_memory/store/store_manager.rb', line 17

def project_store
  @project_store
end

Class Method Details

.default_global_db_path(env = ENV) ⇒ String

Default global database path from Configuration.

Parameters:

  • env (Hash) (defaults to: ENV) —

    environment variable hash

Returns:

  • (String) 


39
40
41
 
# File 'lib/claude_memory/store/store_manager.rb', line 39

def self.default_global_db_path(env = ENV)
  Configuration.new(env).global_db_path
end

.default_project_db_path(project_path = Dir.pwd) ⇒ String

Default project database path for a given project directory.

Parameters:

  • project_path (String) (defaults to: Dir.pwd) —

    project directory (default: current working directory)

Returns:

  • (String) 


46
47
48
 
# File 'lib/claude_memory/store/store_manager.rb', line 46

def self.default_project_db_path(project_path = Dir.pwd)
  Configuration.new.project_db_path(project_path)
end

Instance Method Details

#close ⇒ void

This method returns an undefined value.

Close both database connections and reset store references.



97
98
99
100
101
102
 
# File 'lib/claude_memory/store/store_manager.rb', line 97

def close
  @global_store&.close
  @project_store&.close
  @global_store = nil
  @project_store = nil
end

#default_store(prefer: :project) ⇒ SQLiteStore?

Return whichever store is available, preferring the requested scope. Falls back to the other scope if the preferred DB doesn’t exist on disk yet. Returns nil only when both DBs are missing. Intended for “best-effort” surfaces like activity logging and default dashboard reads where the caller just needs some store to talk to.

Parameters:

  • prefer (Symbol) (defaults to: :project) —

    :project (default) or :global

Returns:



144
145
146
147
148
 
# File 'lib/claude_memory/store/store_manager.rb', line 144

def default_store(prefer: :project)
  primary = (prefer == :global) ? "global" : "project"
  fallback = (prefer == :global) ? "project" : "global"
  store_if_exists(primary) || store_if_exists(fallback)
end

#ensure_both! ⇒ void

This method returns an undefined value.

Open both global and project stores.



72
73
74
75
 
# File 'lib/claude_memory/store/store_manager.rb', line 72

def ensure_both!
  ensure_global!
  ensure_project!
end

#ensure_global! ⇒ SQLiteStore

Open the global store, creating the directory and database if needed. No-op if already open.

Returns:



53
54
55
56
57
58
 
# File 'lib/claude_memory/store/store_manager.rb', line 53

def ensure_global!
  return @global_store if @global_store

  FileUtils.mkdir_p(File.dirname(@global_db_path))
  @global_store = SQLiteStore.new(@global_db_path)
end

#ensure_project! ⇒ SQLiteStore

Open the project store, creating the directory and database if needed. No-op if already open.

Returns:



63
64
65
66
67
68
 
# File 'lib/claude_memory/store/store_manager.rb', line 63

def ensure_project!
  return @project_store if @project_store

  FileUtils.mkdir_p(File.dirname(@project_db_path))
  @project_store = SQLiteStore.new(@project_db_path)
end

#global_exists? ⇒ Boolean

Check whether the global database file exists on disk.

Returns:

  • (Boolean) 


85
86
87
 
# File 'lib/claude_memory/store/store_manager.rb', line 85

def global_exists?
  File.exist?(@global_db_path)
end

#project_exists? ⇒ Boolean

Check whether the project database file exists on disk.

Returns:

  • (Boolean) 


91
92
93
 
# File 'lib/claude_memory/store/store_manager.rb', line 91

def project_exists?
  File.exist?(@project_db_path)
end

#promote_fact(fact_id) ⇒ Integer?

Copy a project-scoped fact (with its entities and provenance) into the global store, making it available across all projects. Runs the global writes in a single transaction for atomicity.

Parameters:

  • fact_id (Integer) —

    project fact row id to promote

Returns:

  • (Integer, nil) —

    the new global fact id, or nil if the fact/subject was not found in the project store



157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
 
# File 'lib/claude_memory/store/store_manager.rb', line 157

def promote_fact(fact_id)
  ensure_both!

  fact = @project_store.facts.where(id: fact_id).first
  return nil unless fact

  subject = @project_store.entities.where(id: fact[:subject_entity_id]).first
  return nil unless subject

  # Read all project data before entering global transaction
  object = fact[:object_entity_id] ? @project_store.entities.where(id: fact[:object_entity_id]).first : nil
  provenance_records = @project_store.provenance.where(fact_id: fact_id).all

  # Wrap all global 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 object
      global_object_id = @global_store.find_or_create_entity(
        type: object[:type],
        name: object[:canonical_name]
      )
    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
    )

    provenance_records.each do |prov|
      @global_store.insert_provenance(
        fact_id: global_fact_id,
        content_item_id: nil,
        quote: prov[:quote],
        attribution_entity_id: nil,
        strength: prov[:strength]
      )
    end

    global_fact_id
  end
end

#store_for_scope(scope) ⇒ SQLiteStore

Return the appropriate store for a given scope string.

Parameters:

  • scope (String) —

    “global” or “project”

Returns:

Raises:

  • (ArgumentError) —

    if scope is not “global” or “project”



108
109
110
111
112
113
114
115
116
117
118
119
 
# File 'lib/claude_memory/store/store_manager.rb', line 108

def store_for_scope(scope)
  case scope
  when "global"
    ensure_global!
    @global_store
  when "project"
    ensure_project!
    @project_store
  else
    raise ArgumentError, "Invalid scope: #{scope}. Use 'global' or 'project'"
  end
end

#store_if_exists(scope) ⇒ SQLiteStore?

Return the store for an explicit scope only if its database file already exists on disk. Never creates a new DB. Useful for read-only surfaces that want to avoid accidental initialization.

Parameters:

  • scope (String) —

    “global” or “project”

Returns:



126
127
128
129
130
131
132
133
134
135
 
# File 'lib/claude_memory/store/store_manager.rb', line 126

def store_if_exists(scope)
  case scope
  when "project"
    return nil unless project_exists?
    ensure_project!
  when "global"
    return nil unless global_exists?
    ensure_global!
  end
end