claude_memory 0.2.0 → 0.3.0

data/lib/claude_memory/commands/checks/reporter.rb

@@ -0,0 +1,110 @@
+# frozen_string_literal: true
+
+module ClaudeMemory
+  module Commands
+    module Checks
+      # Formats and reports check results
+      class Reporter
+        def initialize(stdout, stderr)
+          @stdout = stdout
+          @stderr = stderr
+        end
+
+        def report(results)
+          @stdout.puts "Claude Memory Doctor\n"
+          @stdout.puts "=" * 40
+
+          # Report database checks with detailed output
+          database_results = results.select { |r| r[:label] =~ /global|project/ }
+          database_results.each do |result|
+            @stdout.puts "\n## #{result[:label].capitalize} Database"
+            report_result(result)
+          end
+
+          # Report other checks
+          other_results = results.reject { |r| r[:label] =~ /global|project/ }
+          other_results.each do |result|
+            report_result(result)
+          end
+
+          @stdout.puts
+
+          # Collect and report warnings
+          warnings = results.flat_map { |r| (r[:warnings] || []).map { |w| "#{r[:label]}: #{w}" } }
+          if warnings.any?
+            @stdout.puts "Warnings:"
+            warnings.each { |w| @stdout.puts "  ⚠ #{w}" }
+            @stdout.puts
+          end
+
+          # Collect and report errors
+          errors = results.select { |r| r[:status] == :error }
+          if errors.any?
+            @stdout.puts "Issues:"
+            errors.each { |e| @stderr.puts "  ✗ #{e[:message]}" }
+            errors.flat_map { |e| e[:errors] || [] }.each { |err| @stderr.puts "    • #{err}" }
+            @stdout.puts
+            @stdout.puts "Run 'claude-memory init' to set up."
+            return false
+          end
+
+          @stdout.puts "All checks passed!"
+          true
+        end
+
+        private
+
+        def report_result(result)
+          case result[:status]
+          when :ok
+            @stdout.puts status_line(result)
+            report_details(result)
+          when :warning
+            @stdout.puts status_line(result)
+            report_details(result)
+          when :error
+            # Errors are reported in summary
+            report_details(result) if result[:details]&.any?
+          end
+
+          # Report fallback commands if available
+          if result.dig(:details, :fallback_available)
+            @stdout.puts "\n  Manual fallback available:"
+            result.dig(:details, :fallback_commands)&.each do |cmd|
+              @stdout.puts "    #{cmd}"
+            end
+          end
+        end
+
+        def status_line(result)
+          case result[:status]
+          when :ok
+            "✓ #{result[:message]}"
+          when :warning
+            "⚠ #{result[:message]}"
+          when :error
+            "✗ #{result[:message]}"
+          end
+        end
+
+        def report_details(result)
+          details = result[:details] || {}
+          return if details.empty?
+
+          @stdout.puts "  Adapter: #{details[:adapter]}" if details[:adapter]
+          @stdout.puts "  Schema version: #{details[:schema_version]}" if details[:schema_version]
+          @stdout.puts "  Facts: #{details[:fact_count]}" if details[:fact_count]
+          @stdout.puts "  Content items: #{details[:content_count]}" if details[:content_count]
+          @stdout.puts "  Open conflicts: #{details[:conflict_count]}" if details[:conflict_count]
+          @stdout.puts "  Last ingest: #{details[:last_ingest]}" if details[:last_ingest]
+          @stdout.puts "  Stuck operations: #{details[:stuck_operations]}" if details.key?(:stuck_operations)
+
+          if details.key?(:schema_valid)
+            health = details[:schema_valid] ? "healthy" : "issues detected"
+            @stdout.puts "  Schema health: #{health}"
+          end
+        end
+      end
+    end
+  end
+end

data/lib/claude_memory/commands/checks/snapshot_check.rb

@@ -0,0 +1,30 @@
+# frozen_string_literal: true
+
+module ClaudeMemory
+  module Commands
+    module Checks
+      # Checks if published snapshot exists
+      class SnapshotCheck
+        SNAPSHOT_PATH = ".claude/rules/claude_memory.generated.md"
+
+        def call
+          if File.exist?(SNAPSHOT_PATH)
+            {
+              status: :ok,
+              label: "snapshot",
+              message: "Published snapshot exists",
+              details: {path: SNAPSHOT_PATH}
+            }
+          else
+            {
+              status: :warning,
+              label: "snapshot",
+              message: "No published snapshot found. Run 'claude-memory publish'",
+              details: {path: SNAPSHOT_PATH}
+            }
+          end
+        end
+      end
+    end
+  end
+end

data/lib/claude_memory/commands/doctor_command.rb

@@ -1,146 +1,29 @@
 # frozen_string_literal: true
 
-require "json"
-
 module ClaudeMemory
   module Commands
     # Performs system health checks for ClaudeMemory
-    # Checks databases, snapshots, hooks configuration
+    # Delegates to specialized check classes for actual validation
     class DoctorCommand < BaseCommand
       def call(_args)
-        issues = []
-        warnings = []
-
-        stdout.puts "Claude Memory Doctor\n"
-        stdout.puts "=" * 40
-
         manager = ClaudeMemory::Store::StoreManager.new
 
-        stdout.puts "\n## Global Database"
-        check_database(manager.global_db_path, "global", issues, warnings)
+        checks = [
+          Checks::DatabaseCheck.new(manager.global_db_path, "global"),
+          Checks::DatabaseCheck.new(manager.project_db_path, "project"),
+          Checks::SnapshotCheck.new,
+          Checks::ClaudeMdCheck.new,
+          Checks::HooksCheck.new
+        ]
 
-        stdout.puts "\n## Project Database"
-        check_database(manager.project_db_path, "project", issues, warnings)
+        results = checks.map(&:call)
 
         manager.close
 
-        check_snapshot(warnings)
-        check_claude_md(warnings)
-        check_hooks_config(warnings)
-
-        stdout.puts
-
-        if warnings.any?
-          stdout.puts "Warnings:"
-          warnings.each { |w| stdout.puts "  ⚠ #{w}" }
-          stdout.puts
-        end
-
-        if issues.any?
-          stdout.puts "Issues:"
-          issues.each { |i| stderr.puts "  ✗ #{i}" }
-          stdout.puts
-          stdout.puts "Run 'claude-memory init' to set up."
-          return 1
-        end
-
-        stdout.puts "All checks passed!"
-        0
-      end
-
-      private
-
-      def check_database(db_path, label, issues, warnings)
-        if File.exist?(db_path)
-          stdout.puts "✓ #{label.capitalize} database exists: #{db_path}"
-          begin
-            store = ClaudeMemory::Store::SQLiteStore.new(db_path)
-            stdout.puts "  Schema version: #{store.schema_version}"
-
-            fact_count = store.facts.count
-            stdout.puts "  Facts: #{fact_count}"
-
-            content_count = store.content_items.count
-            stdout.puts "  Content items: #{content_count}"
-
-            conflict_count = store.conflicts.where(status: "open").count
-            if conflict_count > 0
-              warnings << "#{label}: #{conflict_count} open conflict(s) need resolution"
-            end
-            stdout.puts "  Open conflicts: #{conflict_count}"
-
-            last_ingest = store.content_items.max(:ingested_at)
-            if last_ingest
-              stdout.puts "  Last ingest: #{last_ingest}"
-            elsif label == "project"
-              warnings << "#{label}: No content has been ingested yet"
-            end
-
-            store.close
-          rescue => e
-            issues << "#{label} database error: #{e.message}"
-          end
-        elsif label == "global"
-          issues << "Global database not found: #{db_path}"
-        else
-          warnings << "Project database not found: #{db_path} (run 'claude-memory init')"
-        end
-      end
-
-      def check_snapshot(warnings)
-        if File.exist?(".claude/rules/claude_memory.generated.md")
-          stdout.puts "✓ Published snapshot exists"
-        else
-          warnings << "No published snapshot found. Run 'claude-memory publish'"
-        end
-      end
-
-      def check_claude_md(warnings)
-        if File.exist?(".claude/CLAUDE.md")
-          content = File.read(".claude/CLAUDE.md")
-          if content.include?("claude_memory.generated.md")
-            stdout.puts "✓ CLAUDE.md imports snapshot"
-          else
-            warnings << "CLAUDE.md does not import snapshot"
-          end
-        else
-          warnings << "No .claude/CLAUDE.md found"
-        end
-      end
-
-      def check_hooks_config(warnings)
-        settings_path = ".claude/settings.json"
-        local_settings_path = ".claude/settings.local.json"
-
-        hooks_found = false
-
-        [settings_path, local_settings_path].each do |path|
-          next unless File.exist?(path)
-
-          begin
-            config = JSON.parse(File.read(path))
-            if config["hooks"]&.any?
-              hooks_found = true
-              stdout.puts "✓ Hooks configured in #{path}"
-
-              expected_hooks = %w[Stop SessionStart PreCompact SessionEnd]
-              missing = expected_hooks - config["hooks"].keys
-              if missing.any?
-                warnings << "Missing recommended hooks in #{path}: #{missing.join(", ")}"
-              end
-            end
-          rescue JSON::ParserError
-            warnings << "Invalid JSON in #{path}"
-          end
-        end
+        reporter = Checks::Reporter.new(stdout, stderr)
+        success = reporter.report(results)
 
-        unless hooks_found
-          warnings << "No hooks configured. Run 'claude-memory init' or configure manually."
-          stdout.puts "\n  Manual fallback available:"
-          stdout.puts "    claude-memory ingest --session-id <id> --transcript-path <path>"
-          stdout.puts "    claude-memory sweep --budget 5"
-          stdout.puts "    claude-memory publish"
-        end
+        success ? 0 : 1
       end
     end
   end

data/lib/claude_memory/commands/help_command.rb

@@ -26,6 +26,7 @@ module ClaudeMemory
             search     Search indexed content
             serve-mcp  Start MCP server
             sweep      Run maintenance/pruning
+            uninstall  Remove ClaudeMemory configuration
             version    Show version number
 
           Run 'claude-memory <command> --help' for more information on a command.

data/lib/claude_memory/commands/hook_command.rb

@@ -71,8 +71,15 @@ module ClaudeMemory
           stdout.puts "No new content to ingest"
           Hook::ExitCodes::SUCCESS
         when :skipped
-          stdout.puts "Skipped ingestion: #{result[:reason]}"
-          Hook::ExitCodes::WARNING
+          # Different reasons for skipping have different severity
+          if result[:reason] == "unchanged"
+            stdout.puts "No new content to ingest"
+            Hook::ExitCodes::SUCCESS
+          else
+            # transcript_not_found or other skipped reasons
+            stdout.puts "Skipped ingestion: #{result[:reason]}"
+            Hook::ExitCodes::WARNING
+          end
         else
           Hook::ExitCodes::ERROR
         end

data/lib/claude_memory/commands/index_command.rb

@@ -0,0 +1,169 @@
+# frozen_string_literal: true
+
+module ClaudeMemory
+  module Commands
+    # Generates embeddings for facts that don't have them yet
+    class IndexCommand < BaseCommand
+      SCOPE_ALL = "all"
+      SCOPE_GLOBAL = "global"
+      SCOPE_PROJECT = "project"
+
+      def call(args)
+        opts = parse_options(args, {scope: SCOPE_ALL, batch_size: 100, force: false}) do |o|
+          OptionParser.new do |parser|
+            parser.banner = "Usage: claude-memory index [options]"
+            parser.on("--scope SCOPE", "Scope: global, project, or all (default: all)") { |v| o[:scope] = v }
+            parser.on("--batch-size SIZE", Integer, "Batch size (default: 100)") { |v| o[:batch_size] = v }
+            parser.on("--force", "Re-index facts that already have embeddings") { o[:force] = true }
+          end
+        end
+        return 1 if opts.nil?
+
+        unless valid_scope?(opts[:scope])
+          stderr.puts "Invalid scope: #{opts[:scope]}"
+          stderr.puts "Valid scopes: global, project, all"
+          return 1
+        end
+
+        generator = Embeddings::Generator.new
+
+        if opts[:scope] == SCOPE_ALL || opts[:scope] == SCOPE_GLOBAL
+          index_database("global", Configuration.global_db_path, generator, opts)
+        end
+
+        if opts[:scope] == SCOPE_ALL || opts[:scope] == SCOPE_PROJECT
+          index_database("project", Configuration.project_db_path, generator, opts)
+        end
+
+        0
+      end
+
+      private
+
+      def index_database(label, db_path, generator, opts)
+        unless File.exist?(db_path)
+          stdout.puts "#{label.capitalize} database not found, skipping..."
+          return
+        end
+
+        store = Store::SQLiteStore.new(db_path)
+        tracker = Infrastructure::OperationTracker.new(store)
+
+        # Check for existing progress (resumption support)
+        checkpoint = tracker.get_checkpoint(operation_type: "index_embeddings", scope: label)
+        if checkpoint && !opts[:force]
+          stdout.puts "#{label.capitalize} database: Resuming from previous run (processed #{checkpoint[:processed_items]} facts)..."
+          resume_from_fact_id = checkpoint[:checkpoint_data][:last_fact_id]
+        else
+          resume_from_fact_id = nil
+        end
+
+        # Find facts to index
+        facts_dataset = if opts[:force]
+          store.facts
+        else
+          store.facts.where(embedding_json: nil)
+        end
+
+        # If resuming, skip facts we've already processed
+        if resume_from_fact_id
+          facts_dataset = facts_dataset.where(Sequel.lit("id > ?", resume_from_fact_id))
+        end
+
+        facts = facts_dataset.order(:id).all
+
+        if facts.empty? && !checkpoint
+          stdout.puts "#{label.capitalize} database: All facts already indexed"
+          store.close
+          return
+        elsif facts.empty? && checkpoint
+          # Resume found nothing left to do - mark as completed
+          tracker.complete_operation(checkpoint[:operation_id])
+          stdout.puts "#{label.capitalize} database: Resumed operation completed (nothing left to index)"
+          store.close
+          return
+        end
+
+        # Start or continue operation tracking
+        operation_id = checkpoint ? checkpoint[:operation_id] : tracker.start_operation(
+          operation_type: "index_embeddings",
+          scope: label,
+          total_items: facts.size,
+          checkpoint_data: {last_fact_id: nil}
+        )
+
+        stdout.puts "#{label.capitalize} database: Indexing #{facts.size} facts..."
+
+        processed = checkpoint ? checkpoint[:processed_items] : 0
+        begin
+          facts.each_slice(opts[:batch_size]) do |batch|
+            # Wrap batch processing in transaction for atomicity
+            store.db.transaction do
+              batch.each do |fact|
+                # Generate text representation
+                text = build_fact_text(fact, store)
+
+                # Generate embedding
+                embedding = generator.generate(text)
+
+                # Store embedding
+                store.update_fact_embedding(fact[:id], embedding)
+
+                processed += 1
+              end
+
+              # Update checkpoint after batch commits
+              last_fact_id = batch.last[:id]
+              tracker.update_progress(
+                operation_id,
+                processed_items: processed,
+                checkpoint_data: {last_fact_id: last_fact_id}
+              )
+            end
+
+            stdout.puts "  Processed #{processed} facts..."
+          end
+
+          # Mark operation as completed
+          tracker.complete_operation(operation_id)
+          stdout.puts "  Done!"
+        rescue => e
+          # Mark operation as failed
+          tracker.fail_operation(operation_id, e.message)
+          stderr.puts "  Failed: #{e.message}"
+          raise
+        ensure
+          store.close
+        end
+      end
+
+      def build_fact_text(fact, store)
+        # Build rich text representation for embedding
+        parts = []
+
+        # Subject
+        if fact[:subject_entity_id]
+          subject = store.entities.where(id: fact[:subject_entity_id]).first
+          parts << subject[:canonical_name] if subject
+        end
+
+        # Predicate
+        parts << fact[:predicate]
+
+        # Object
+        if fact[:object_entity_id]
+          object_entity = store.entities.where(id: fact[:object_entity_id]).first
+          parts << object_entity[:canonical_name] if object_entity
+        elsif fact[:object_literal]
+          parts << fact[:object_literal]
+        end
+
+        parts.join(" ")
+      end
+
+      def valid_scope?(scope)
+        [SCOPE_ALL, SCOPE_GLOBAL, SCOPE_PROJECT].include?(scope)
+      end
+    end
+  end
+end

data/lib/claude_memory/commands/ingest_command.rb

@@ -32,7 +32,7 @@ module ClaudeMemory
         case result[:status]
         when :ingested
           stdout.puts "Ingested #{result[:bytes_read]} bytes (content_id: #{result[:content_id]})"
-        when :no_change
+        when :no_change, :skipped
           stdout.puts "No new content to ingest"
         end