claude_memory 0.1.0 → 0.2.0

data/lib/claude_memory/index/query_options.rb

@@ -0,0 +1,67 @@
+# frozen_string_literal: true
+
+module ClaudeMemory
+  module Index
+    class QueryOptions
+      SCOPE_ALL = :all
+      SCOPE_PROJECT = :project
+      SCOPE_GLOBAL = :global
+
+      DEFAULT_LIMIT = 20
+      DEFAULT_SCOPE = SCOPE_ALL
+
+      attr_reader :query_text, :limit, :scope, :source
+
+      def initialize(query_text:, limit: DEFAULT_LIMIT, scope: DEFAULT_SCOPE, source: nil)
+        @query_text = query_text
+        @limit = limit
+        @scope = scope.to_sym
+        @source = source&.to_sym
+        freeze
+      end
+
+      def for_project
+        self.class.new(
+          query_text: query_text,
+          limit: limit,
+          scope: scope,
+          source: :project
+        )
+      end
+
+      def for_global
+        self.class.new(
+          query_text: query_text,
+          limit: limit,
+          scope: scope,
+          source: :global
+        )
+      end
+
+      def with_limit(new_limit)
+        self.class.new(
+          query_text: query_text,
+          limit: new_limit,
+          scope: scope,
+          source: source
+        )
+      end
+
+      def ==(other)
+        other.is_a?(QueryOptions) &&
+          other.query_text == query_text &&
+          other.limit == limit &&
+          other.scope == scope &&
+          other.source == source
+      end
+
+      def eql?(other)
+        self == other
+      end
+
+      def hash
+        [query_text, limit, scope, source].hash
+      end
+    end
+  end
+end

data/lib/claude_memory/infrastructure/file_system.rb

@@ -0,0 +1,29 @@
+# frozen_string_literal: true
+
+require "fileutils"
+require "digest/sha2"
+
+module ClaudeMemory
+  module Infrastructure
+    # Real filesystem implementation
+    # Wraps File and FileUtils for dependency injection
+    class FileSystem
+      def exist?(path)
+        File.exist?(path)
+      end
+
+      def read(path)
+        File.read(path)
+      end
+
+      def write(path, content)
+        FileUtils.mkdir_p(File.dirname(path))
+        File.write(path, content)
+      end
+
+      def file_hash(path)
+        Digest::SHA256.file(path).hexdigest
+      end
+    end
+  end
+end

data/lib/claude_memory/infrastructure/in_memory_file_system.rb

@@ -0,0 +1,32 @@
+# frozen_string_literal: true
+
+require "digest/sha2"
+
+module ClaudeMemory
+  module Infrastructure
+    # In-memory filesystem implementation for fast testing
+    # Does not touch the real filesystem
+    class InMemoryFileSystem
+      def initialize
+        @files = {}
+      end
+
+      def exist?(path)
+        @files.key?(path)
+      end
+
+      def read(path)
+        @files.fetch(path) { raise Errno::ENOENT, path }
+      end
+
+      def write(path, content)
+        @files[path] = content
+      end
+
+      def file_hash(path)
+        content = read(path)
+        Digest::SHA256.hexdigest(content)
+      end
+    end
+  end
+end

data/lib/claude_memory/ingest/content_sanitizer.rb

@@ -0,0 +1,42 @@
+# frozen_string_literal: true
+
+module ClaudeMemory
+  module Ingest
+    class ContentSanitizer
+      SYSTEM_TAGS = ["claude-memory-context"].freeze
+      USER_TAGS = ["private", "no-memory", "secret"].freeze
+      MAX_TAG_COUNT = 100
+
+      def self.strip_tags(text)
+        tags = Pure.all_tags
+        validate_tag_count!(text, tags)
+        Pure.strip_tags(text, tags)
+      end
+
+      def self.validate_tag_count!(text, tags)
+        count = Pure.count_tags(text, tags)
+        raise Error, "Too many privacy tags (#{count}), possible ReDoS attack" if count > MAX_TAG_COUNT
+      end
+
+      module Pure
+        def self.all_tags
+          @all_tags ||= begin
+            all_tag_names = ContentSanitizer::SYSTEM_TAGS + ContentSanitizer::USER_TAGS
+            all_tag_names.map { |name| PrivacyTag.new(name) }
+          end
+        end
+
+        def self.strip_tags(text, tags)
+          tags.reduce(text) { |result, tag| tag.strip_from(result) }
+        end
+
+        def self.count_tags(text, tags)
+          tags.sum do |tag|
+            opening_pattern = /<#{Regexp.escape(tag.name)}>/
+            text.scan(opening_pattern).size
+          end
+        end
+      end
+    end
+  end
+end

data/lib/claude_memory/ingest/ingester.rb

@@ -17,6 +17,9 @@ module ClaudeMemory
 
         return {status: :no_change, bytes_read: 0} if delta.nil?
 
+        # Strip privacy tags before storing
+        delta = ContentSanitizer.strip_tags(delta)
+
         resolved_project = project_path || detect_project_path
 
         text_hash = Digest::SHA256.hexdigest(delta)

data/lib/claude_memory/ingest/privacy_tag.rb

@@ -0,0 +1,48 @@
+# frozen_string_literal: true
+
+module ClaudeMemory
+  module Ingest
+    class PrivacyTag
+      attr_reader :name
+
+      def initialize(name)
+        @name = name.to_s.strip
+        validate!
+        freeze
+      end
+
+      def pattern
+        /<#{Regexp.escape(@name)}>.*?<\/#{Regexp.escape(@name)}>/m
+      end
+
+      def strip_from(text)
+        # Strip repeatedly to handle nested tags
+        result = text
+        loop do
+          new_result = result.gsub(pattern, "")
+          break if new_result == result
+          result = new_result
+        end
+        result
+      end
+
+      def ==(other)
+        other.is_a?(PrivacyTag) && other.name == name
+      end
+
+      def eql?(other)
+        self == other
+      end
+
+      def hash
+        name.hash
+      end
+
+      private
+
+      def validate!
+        raise Error, "Tag name cannot be empty" if @name.empty?
+      end
+    end
+  end
+end

data/lib/claude_memory/mcp/tools.rb

@@ -31,6 +31,31 @@ module ClaudeMemory
               required: ["query"]
             }
           },
+          {
+            name: "memory.recall_index",
+            description: "Layer 1: Search for facts and get lightweight index (IDs, previews, token counts). Use this first before fetching full details.",
+            inputSchema: {
+              type: "object",
+              properties: {
+                query: {type: "string", description: "Search query for fact discovery"},
+                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"}
+              },
+              required: ["query"]
+            }
+          },
+          {
+            name: "memory.recall_details",
+            description: "Layer 2: Fetch full details for specific fact IDs from the index. Use after memory.recall_index to get complete information.",
+            inputSchema: {
+              type: "object",
+              properties: {
+                fact_ids: {type: "array", items: {type: "integer"}, description: "Fact IDs from memory.recall_index"},
+                scope: {type: "string", enum: ["project", "global"], description: "Database to query", default: "project"}
+              },
+              required: ["fact_ids"]
+            }
+          },
           {
             name: "memory.explain",
             description: "Get detailed explanation of a fact with provenance",
@@ -148,6 +173,36 @@ module ClaudeMemory
               },
               required: ["facts"]
             }
+          },
+          {
+            name: "memory.decisions",
+            description: "Quick access to architectural decisions, constraints, and rules",
+            inputSchema: {
+              type: "object",
+              properties: {
+                limit: {type: "integer", default: 10, description: "Maximum results to return"}
+              }
+            }
+          },
+          {
+            name: "memory.conventions",
+            description: "Quick access to coding conventions and style preferences (global scope)",
+            inputSchema: {
+              type: "object",
+              properties: {
+                limit: {type: "integer", default: 20, description: "Maximum results to return"}
+              }
+            }
+          },
+          {
+            name: "memory.architecture",
+            description: "Quick access to framework choices and architectural patterns",
+            inputSchema: {
+              type: "object",
+              properties: {
+                limit: {type: "integer", default: 10, description: "Maximum results to return"}
+              }
+            }
           }
         ]
       end
@@ -156,6 +211,10 @@ module ClaudeMemory
         case name
         when "memory.recall"
           recall(arguments)
+        when "memory.recall_index"
+          recall_index(arguments)
+        when "memory.recall_details"
+          recall_details(arguments)
         when "memory.explain"
           explain(arguments)
         when "memory.changes"
@@ -170,6 +229,12 @@ module ClaudeMemory
           promote(arguments)
         when "memory.store_extraction"
           store_extraction(arguments)
+        when "memory.decisions"
+          decisions(arguments)
+        when "memory.conventions"
+          conventions(arguments)
+        when "memory.architecture"
+          architecture(arguments)
         else
           {error: "Unknown tool: #{name}"}
         end
@@ -195,10 +260,80 @@ module ClaudeMemory
         }
       end
 
+      def recall_index(args)
+        scope = args["scope"] || "all"
+        results = @recall.query_index(args["query"], limit: args["limit"] || 20, scope: scope)
+
+        total_tokens = results.sum { |r| r[:token_estimate] }
+
+        {
+          query: args["query"],
+          scope: scope,
+          result_count: results.size,
+          total_estimated_tokens: total_tokens,
+          facts: results.map do |r|
+            {
+              id: r[:id],
+              subject: r[:subject],
+              predicate: r[:predicate],
+              object_preview: r[:object_preview],
+              status: r[:status],
+              scope: r[:scope],
+              confidence: r[:confidence],
+              tokens: r[:token_estimate],
+              source: r[:source]
+            }
+          end
+        }
+      end
+
+      def recall_details(args)
+        fact_ids = args["fact_ids"]
+        scope = args["scope"] || "project"
+
+        # Batch fetch detailed explanations
+        explanations = fact_ids.map do |fact_id|
+          explanation = @recall.explain(fact_id, scope: scope)
+          next nil if explanation.is_a?(Core::NullExplanation)
+
+          {
+            fact: {
+              id: explanation[:fact][:id],
+              subject: explanation[:fact][:subject_name],
+              predicate: explanation[:fact][:predicate],
+              object: explanation[:fact][:object_literal],
+              status: explanation[:fact][:status],
+              confidence: explanation[:fact][:confidence],
+              scope: explanation[:fact][:scope],
+              valid_from: explanation[:fact][:valid_from],
+              valid_to: explanation[:fact][:valid_to]
+            },
+            receipts: explanation[:receipts].map { |r|
+              {
+                quote: r[:quote],
+                strength: r[:strength],
+                session_id: r[:session_id],
+                occurred_at: r[:occurred_at]
+              }
+            },
+            relationships: {
+              supersedes: explanation[:supersedes],
+              superseded_by: explanation[:superseded_by],
+              conflicts: explanation[:conflicts].map { |c| {id: c[:id], status: c[:status]} }
+            }
+          }
+        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"} unless explanation
+        return {error: "Fact not found in #{scope} database"} if explanation.is_a?(Core::NullExplanation)
 
         {
           fact: {
@@ -394,6 +529,44 @@ module ClaudeMemory
         end
       end
 
+      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
+
+      def format_shortcut_results(results, category)
+        {
+          category: category,
+          count: results.size,
+          facts: results.map do |r|
+            {
+              id: r[:fact][:id],
+              subject: r[:fact][:subject_name],
+              predicate: r[:fact][:predicate],
+              object: r[:fact][:object_literal],
+              scope: r[:fact][:scope],
+              source: r[:source]
+            }
+          end
+        }
+      end
+
       def db_stats(store)
         {
           exists: true,

data/lib/claude_memory/publish.rb

@@ -8,8 +8,9 @@ module ClaudeMemory
     RULES_DIR = ".claude/rules"
     GENERATED_FILE = "claude_memory.generated.md"
 
-    def initialize(store)
+    def initialize(store, file_system: Infrastructure::FileSystem.new)
       @store = store
+      @fs = file_system
     end
 
     def generate_snapshot(since: nil)
@@ -38,15 +39,13 @@ module ClaudeMemory
       header + sections.compact.reject(&:empty?).join("\n")
     end
 
-    def publish!(mode: :shared, granularity: :repo, since: nil)
+    def publish!(mode: :shared, granularity: :repo, since: nil, rules_dir: nil)
       content = generate_snapshot(since: since)
-      path = output_path(mode)
-
-      FileUtils.mkdir_p(File.dirname(path))
+      path = output_path(mode, rules_dir: rules_dir)
 
       if should_write?(path, content)
-        File.write(path, content)
-        ensure_import_exists(mode, path)
+        @fs.write(path, content)
+        ensure_import_exists(mode, path, rules_dir: rules_dir)
         {status: :updated, path: path}
       else
         {status: :unchanged, path: path}
@@ -55,17 +54,19 @@ module ClaudeMemory
 
     private
 
-    def output_path(mode)
+    def output_path(mode, rules_dir: nil)
       case mode
       when :shared
-        File.join(RULES_DIR, GENERATED_FILE)
+        dir = rules_dir || RULES_DIR
+        File.join(dir, GENERATED_FILE)
       when :local
         ".claude_memory.local.md"
       when :home
         project_name = File.basename(Dir.pwd)
         File.join(Dir.home, ".claude", "claude_memory", "#{project_name}.md")
       else
-        File.join(RULES_DIR, GENERATED_FILE)
+        dir = rules_dir || RULES_DIR
+        File.join(dir, GENERATED_FILE)
       end
     end
 
@@ -163,34 +164,42 @@ module ClaudeMemory
     end
 
     def should_write?(path, content)
-      return true unless File.exist?(path)
+      return true unless @fs.exist?(path)
 
-      existing_hash = Digest::SHA256.file(path).hexdigest
+      existing_hash = @fs.file_hash(path)
       new_hash = Digest::SHA256.hexdigest(content)
       existing_hash != new_hash
     end
 
-    def ensure_import_exists(mode, path)
+    def ensure_import_exists(mode, path, rules_dir: nil)
       return if mode == :local
 
-      claude_md = ".claude/CLAUDE.md"
+      # Determine CLAUDE.md location based on rules_dir
+      claude_md = if rules_dir
+        # If rules_dir is provided (e.g., /tmp/xyz/.claude/rules),
+        # CLAUDE.md should be in parent dir (e.g., /tmp/xyz/.claude/CLAUDE.md)
+        File.join(File.dirname(rules_dir), "CLAUDE.md")
+      else
+        ".claude/CLAUDE.md"
+      end
+
       import_line = case mode
       when :shared
-        "@#{RULES_DIR}/#{GENERATED_FILE}"
+        dir = rules_dir || RULES_DIR
+        "@#{dir}/#{GENERATED_FILE}"
       when :home
         "@~/#{path.sub(Dir.home + "/", "")}"
       else
         "@#{path}"
       end
 
-      if File.exist?(claude_md)
-        content = File.read(claude_md)
+      if @fs.exist?(claude_md)
+        content = @fs.read(claude_md)
         return if content.include?(import_line)
 
-        File.write(claude_md, content + "\n#{import_line}\n")
+        @fs.write(claude_md, content + "\n#{import_line}\n")
       else
-        FileUtils.mkdir_p(".claude")
-        File.write(claude_md, "# Project Memory\n\n#{import_line}\n")
+        @fs.write(claude_md, "# Project Memory\n\n#{import_line}\n")
       end
     end