ollama_chat 0.0.100 → 0.0.101

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 436406ccfaa267c8996e6986759b3f79773ad8b48127ed8b7f7bd749b8c82dd1
-  data.tar.gz: f2a66b87ebc221adf19e382568979f57baabfabef49929e123bbe0cc1932916d
+  metadata.gz: 55511ef08f35b482ac7529dae4b9e4d9cb490bd37467fac563b966f3ad87f569
+  data.tar.gz: 26846b60e0ef32214b21a1e56128b4be6dbe6bd0808f195c8130186c01f8975c
 SHA512:
-  metadata.gz: 576fc144f38595bec62043b30c170dc65a2bb891df41ab36bdd1b4bef2ad32dbe0b72b413d0e0f785604c0c0e3add5ca847e6da25144011518d67241b7fb8771
-  data.tar.gz: e3c808321e651a55bdf29326d41150700bcd2c8b28d4b2b407c49fdd6aff156e4e4d8555eafb1cf10c46589e44963714dafea95f667305c4173e788cd514da7f
+  metadata.gz: 1d7960e9303887e5ef3571b79bffbf2cd30785c8db4051e6fc7a16f828e7d5dbe8754006a5356074c83fb989dd35b27b5311d1e676c330f4303a81014d16c4ac
+  data.tar.gz: dfcb0fee96b6093e0d30cd7cb4894aa25752054236d85a14161519fb781d1697c7011816441dbdddfeb3477872c057b9382c594b2691c40f3238c9c727d43843

data/CHANGES.md

@@ -1,5 +1,46 @@
 # Changes
 
+## 2026-07-26 v0.0.101
+
+### Added
+
+- Introduced a `clean` subcommand to `/conversation` to remove tool content,
+  images, and thinking from messages in place, including a confirmation prompt
+  for the destructive operation.
+- Implemented `OllamaChat::Utils::LogViewer` and the `bin/ollama_chat_log`
+  utility for real-time, colorized JSON log tailing with regex filtering.
+- Added `estimate_tokens` and `count_messages` helper methods to
+  `OllamaChat::Database::Models::Session`.
+- Implemented `clean_messages!` in `MessageList` with associated YARD
+  documentation.
+
+### Changed
+
+- Enhanced file patching integrity by replacing `mtime` and `line_count` checks
+  with a CRC32 `checksum`. This acts as a "proof of reading": since LLMs cannot
+  calculate CRC32 in their head, echoing the checksum proves they have the
+  latest file context including linenumbers without requiring cryptographic
+  security.
+- Updated `read_file` to conditionally return `checksum` only when full-file
+  line numbers are requested, optimizing token usage for non-patching workflows.
+- Refactored `OllamaChat::Logging#log` to use `deep_transform` for payload
+  sanitization, handling circular references and non-serializable objects.
+- Standardized the `tool: name` variable across 28+ tool classes to ensure
+  consistent audit trails.
+- Expanded logging coverage for file operations, grep, tests, RAG handling,
+  session management, and clipboard operations.
+- Split `OllamaChat::FollowChat#eval_stats` into a data extraction method
+  `stats_hash` and a separate formatting method.
+- Updated `/conversation` command to support the `-c` flag for `save` and added
+  path validation for `save` and `load` subcommands.
+- Modified `lib/ollama_chat/tools/patch_file.rb` to validate that `edits` is an
+  `Array` and handle `checksum` mismatches.
+
+### Fixed
+
+- Improved option parsing scope within the `/conversation` command by moving
+  logic inside the `when 'save'` block.
+
 ## 2026-07-23 v0.0.100
 
 ### New Features

data/README.md

@@ -120,7 +120,7 @@ A source isn't just a filename; it can be any of the following:
 *   **Remote URLs**: Any `http://` or `https://` link. The command will fetch the
     web content and parse it before importing.
 *   **Shell Commands (`!`)**: Any source starting with an exclamation mark is
-    executed as a shell command, and its **STDOUT** is imported as the content. 
+    executed as a shell command, and its **STDOUT** is imported as the content.
     *   *Example*: `/input !ls -la` imports the current directory listing.
     *   *Example*: `/input !git branch` tells the AI which branch you are on.
 
@@ -358,6 +358,56 @@ functionality:
 These parameters provide greater flexibility in how you interact with
 `ollama_chat`, whether from the command line or integrated tools like `vim`.
 
+### Using `ollama_chat_log` to Inspect Application Logs
+
+OllamaChat produces structured JSON logs that capture every tool execution,
+conversation state, and internal event. The `ollama_chat_log` utility allows you
+to filter, colorize, and tail these logs in real-time, displaying the full
+structured data payload by default.
+
+#### Basic Usage
+
+By default, `ollama_chat_log` reads the current session's log file located at
+`~/.local/state/ollama_chat/chat.json` (or wherever the default points).
+
+```bash
+# Show the last 10 log entries
+$ ollama_chat_log
+
+# Show the last 50 entries
+$ ollama_chat_log -n 50
+```
+
+#### Real-time Tailing
+
+Use the `-f` flag to follow the log file as new entries are appended, similar to
+`tail -f`.
+
+```bash
+$ ollama_chat_log -f
+```
+
+#### Filtering Logs with `-m`
+
+The `-m` flag allows you to filter logs based on nested JSON paths using dot
+notation. You can match for key presence or substring matches within values.
+
+- **Key Presence**: `-m "data.tool"` (shows only logs that have a `tool` key)
+- **Substring Match**: `-m "data.tool=read_file"` (shows logs where the tool is `read_file`)
+- **Nested Paths**: `-m "data.function.name=patch_file"`
+- **Regexp Match**: `-m "data.tool=^(write_file|patch_file)$"`
+
+You can chain multiple `-m` flags together. All patterns must match for a log
+entry to be displayed (AND logic).
+
+```bash
+# Show only successful file reads
+$ ollama_chat_log -m "data.tool=read_file" -m "level=info"
+
+# Follow and watch for specific tool executions
+$ ollama_chat_log -f -m "data.tool=execute_grep"
+```
+
 ## Available Tools
 
 The assistant can interact with the system using a variety of tools to gather

data/Rakefile

@@ -60,6 +60,7 @@ GemHadar do
   dependency             'infobar',               '>= 0.13.1'
   dependency             'rubyzip',               '~> 3.0'
   dependency             'sequel',                '~> 5.0'
+  dependency             'file-tail',             '~> 1.4'
   development_dependency 'all_images',            '~> 0.12'
   development_dependency 'rspec',                 '~> 3.2'
   development_dependency 'kramdown',              '~> 2.0'

data/bin/ollama_chat_log

@@ -0,0 +1,64 @@
+#!/usr/bin/env ruby
+
+require 'ollama_chat'
+require 'file/tail'
+require 'tins/xt'
+
+opts     = Tins::GO.go 'fm:n:h:', defaults: { ?n => 10  }
+log_path = ARGV.shift || OC::OLLAMA::CHAT::LOGFILE
+
+if opts[?h]
+  puts <<~EOT
+    Usage: #{File.basename($0)} [OPTIONS] [LOGFILE]
+
+    Options:
+    -f            Follow the log file (real-time tailing)
+    -n NUMBER     Rewind and show the last NUMBER of lines before starting
+    -m MATCH      Filter logs by JSON key paths and values (can be used multiple times)
+                  - Key presence match: -m "data.tool"
+                  - Substring match:    -m "data.tool=read_file" or -m "level=ERROR"
+                  - Regexp match:       -m "data.tool=^(write_file|patch_file)$"
+                  - Nested path match:  -m "data.function.name=write_file"
+    -h            Show this help
+
+    LOGFILE       Path to the JSON log file (defaults to the current chat log)
+  EOT
+  exit 0
+end
+
+unless File.exist?(log_path)
+  STDERR.puts "Error: Log file not found at #{log_path.inspect}"
+  exit 1
+end
+
+# The processing loop
+def process_logs(path, follow: false, rewind: 0, display_data: true, match: nil)
+  if follow
+    # Real-time tailing implementation
+    puts "Watching logs... (Ctrl+C to stop)"
+    File::Tail::Logfile.open(path, backward: rewind) do |log|
+      log.tail do |line|
+        output = OllamaChat::Utils::LogViewer.format_line(line, display_data:, match:)
+        output or next
+        puts output
+      end
+    end
+  else
+    File::Tail::Logfile.open(path, backward: rewind) do |log|
+      log.each do |line|
+        output = OllamaChat::Utils::LogViewer.format_line(line, display_data:, match:)
+        output or next
+        puts output
+      end
+    end
+  end
+rescue Interrupt
+  puts "\nStopping log viewer..."
+end
+
+process_logs(
+  log_path,
+  follow:       opts[?f],
+  rewind:       opts[?n].to_i,
+  match:        opts[?m]
+)

data/lib/ollama_chat/chat.rb

@@ -15,6 +15,7 @@ require 'csv'
 require 'socket'
 require 'shellwords'
 require 'context_spook'
+require 'zlib'
 
 # A chat client for interacting with Ollama models through a terminal
 # interface.
@@ -160,9 +161,9 @@ class OllamaChat::Chat
   # @return [Array] a list of images to be sent with the next prompt
   attr_reader :images
 
-  # Provides read-only access to the cache instance used by the object
+  # Provides read-only access to the cache instance used by the object.
   #
-  # @attr_reader [Cache] the cache instance
+  # @return [OllamaChat::RedisCache, nil] the cache instance
   attr_reader :cache
 
   # The start method initializes the chat session by displaying information,
@@ -289,7 +290,13 @@ class OllamaChat::Chat
   # @param opts [Hash] keyword arguments for the chat call
   # @param block [Proc] optional handler block
   def call_ollama_chat(**opts, &block)
-    log(:info, "Ollama chat request", data: { opts: })
+    if debug
+      log(:debug, "Ollama chat request sent", data: opts)
+    else
+      clean_opts = opts.dup
+      clean_opts = clean_opts.slice!(:messages, :tools)
+      log(:info, "Ollama chat request sent", data: clean_opts)
+    end
     ollama.chat(**opts, &block)
   end
 
@@ -414,6 +421,8 @@ class OllamaChat::Chat
   # The method also handles server socket messages, manages chat history, and
   # ensures proper cleanup and configuration handling throughout the
   # interaction.
+  #
+  # @return [Integer] returns 0 on successful completion or raises an error
   def interact_with_user
     loop do
       content           = nil
@@ -634,7 +643,7 @@ class OllamaChat::Chat
     end
   end
 
-  # Adds documents from command line arguments to the document collection
+  # Adds documents from command line arguments to the document collection.
   #
   # Processes a list of document paths or URLs, handling both local files and
   # remote resources.

data/lib/ollama_chat/clipboard.rb

@@ -109,14 +109,17 @@ module OllamaChat::Clipboard
   # message to standard error and does not re-raise the exception.
   #
   # @param edit [truthy/falsy] If true, opens the content in the editor for
-  #   modification before copying (default: true)
+  #   modification before copying (default: false)
   #
   # @return [TrueClass] if the copying has been performed successfully.
   def copy_to_clipboard(edit: false)
-    perform_copy_to_clipboard(edit:)
+    text = last_message_content(content: false)
+    perform_copy_to_clipboard(text: text, edit:)
+    log(:info, "Copied to clipboard", data: { bytes: format_bytes(text.bytesize) }) if text
     STDOUT.puts "The last response has been successfully copied to the system clipboard."
     true
   rescue OllamaChat::OllamaChatError => e
+    log(:error, e, data: { method: __method__ })
     STDERR.puts e.message
   end
 
@@ -133,9 +136,11 @@ module OllamaChat::Clipboard
   #   or nil if an error occurred
   def paste_from_clipboard(edit: false)
     result = perform_paste_from_clipboard(edit:)
+    log(:info, "Pasted from clipboard", data: { bytes: format_bytes(result.bytesize) }) if result
     STDOUT.puts "The clipboard content has been successfully copied to the chat."
     result
   rescue OllamaChat::OllamaChatError => e
+    log(:error, e, data: { method: __method__ })
     STDERR.puts e.message
   end
 end

data/lib/ollama_chat/commands.rb

@@ -523,21 +523,37 @@ module OllamaChat::Commands
 
   command(
     name: :conversation,
-    regexp: %r(^/conversation\s+(save|load)((?:\s+-(?:[c]))*)\s+([^-].*)$),
-    complete: [ 'conversation', %w[ save load ] ],
+    regexp: %r(^/conversation\s+(clean|save|load)(\s+-c)?(?:\s+([^-].*))?$),
+    complete: [ 'conversation', %w[ save load clean ] ],
     options: '[-c]',
     help: <<~EOT
       💾 Save/Load conversation state
-         (-c to clean first)
+         (-c to clean before saving)
+         Or clean inplace (removes tool content, images, and thinking)
     EOT
   ) do |subcommand,opts,path|
-    opts = go_command('c', opts.to_s)
+    if %w[ save load ].include?(subcommand) && path.blank?
+      STDERR.puts "Require a path as argument to save/load!"
+      next :next
+    end
     case subcommand
     when 'save'
+      opts = go_command('c', opts.to_s)
       save_conversation(path, clean: opts[?c])
     when 'load'
       load_conversation(path)
       repair_group_uuids
+    when 'clean'
+      if confirm?(
+          prompt: '🔔 Clean tool content, images, and thinking from conversation? (y/n) ',
+          yes: /\Ay/i
+        )
+      then
+        messages.clean_messages!
+        STDOUT.puts "Conversation cleaned."
+      else
+        STDOUT.puts 'Cancelled.'
+      end
     end
     :next
   end

data/lib/ollama_chat/database/models/session.rb

@@ -50,6 +50,21 @@ class OllamaChat::Database::Models::Session < Sequel::Model(OllamaChat::DB)
     Tins::Duration.new(updated_at ? now - updated_at : 0)
   end
 
+  # Estimates the token and byte size of the session's message history.
+  #
+  # @return [OllamaChat::TokenEstimator::Estimate] the estimated token and byte counts
+  def estimate_tokens
+    size_bytes = messages.to_s.size
+    OllamaChat::TokenEstimator.estimate(size_bytes)
+  end
+
+  # Counts the number of messages in the session's JSONL history.
+  #
+  # @return [Integer] the number of messages stored in the session
+  def count_messages
+    messages.to_s.count(?\n)
+  end
+
   # @!attribute [v] id
   #   @return [Integer] The primary key for the session.
   #
@@ -128,13 +143,11 @@ class OllamaChat::Database::Models::Session < Sequel::Model(OllamaChat::DB)
   # @!attribute [v] updated_at
   #   @return [Time, nil] The timestamp of the last update to the session.
 
-  # The with_defaults method is a factory method that initializes a new
-  # Session model instance with a set of default values derived
-  # from the
-  # @param chat [OllamaChat::Chat] the active chat instance used to
-  #   extract
-  # @return [OllamaChat::Database::Models::Session] a new session
-  #   instance with default attributes
+  # Factory method that initializes a new Session model instance with a set
+  # of default values derived from the active chat configuration.
+  #
+  # @param chat [OllamaChat::Chat] the active chat instance used to extract defaults
+  # @return [OllamaChat::Database::Models::Session] a new session instance with default attributes
   def self.with_defaults(chat)
     tools_default_enabled =
       chat.config.tools.functions.to_h.

data/lib/ollama_chat/favourites_management.rb

@@ -54,6 +54,7 @@ module OllamaChat::FavouritesManagement
           return
         when SearchUI::Wrapper
           models::Favourite.create(context: type, name: chosen.value)
+          log(:info, "Favourite added", data: { context: type, name: chosen.value })
         end
       end
     end
@@ -80,6 +81,7 @@ module OllamaChat::FavouritesManagement
           return
         when SearchUI::Wrapper
           models::Favourite.where(context: type, name: chosen.value).destroy
+          log(:info, "Favourite removed", data: { context: type, name: chosen.value })
         end
       end
     end

data/lib/ollama_chat/follow_chat.rb

@@ -15,12 +15,13 @@ class OllamaChat::FollowChat
 
   # Initializes a new instance of OllamaChat::FollowChat.
   #
-  # @param [OllamaChat::Chat] chat The chat object, which represents the
+  # @param chat [OllamaChat::Chat] The chat object, which represents the
   #   conversation context.
-  # @param [#to_a] messages A collection of message objects, representing the
+  # @param messages [#to_a] A collection of message objects, representing the
   #   conversation history.
-  # @param [String] voice (optional) to speek with if any.
-  # @param [IO] output (optional) The output stream where terminal output
+  # @param group_uuid [String, nil] The group UUID for the conversation.
+  # @param voice [String, nil] (optional) The voice to speak with.
+  # @param output [IO] (optional) The output stream where terminal output
   #   should be printed. Defaults to STDOUT.
   #
   # @return [OllamaChat::FollowChat] A new instance of OllamaChat::FollowChat.
@@ -167,21 +168,20 @@ class OllamaChat::FollowChat
         )
         result = OllamaChat::Tools.registered[name].execute(tool_call, chat:)
         if confirmed == :explicit
-          chat.log(:info, "Tool execution confirmed", data: { tool: name, confirmation: :explicit })
+          chat.log(:info, "Tool execution confirmed", data: { tool: name, confirmed: })
         else
-          chat.log(:info, "Tool execution confirmed", data: { tool: name, confirmation: :implicit })
+          chat.log(:info, "Tool execution confirmed", data: { tool: name, confirmed: })
         end
       end
 
       chat.tool_call_results[name] << result
-
       data    = nil
       message = begin
                    data = JSON.parse(result)
-                   chat.log(:info, "Tool result", data:)
-                   data['message']
+                   chat.log(:info, "Tool result", data: { result: data })
+                   data.to_hash['message'] if data.respond_to?(:to_hash)
                  rescue
-                   chat.log(:info, "Tool result", data: { raw_result: result })
+                   chat.log(:info, "Tool result", data: { result: })
                    nil
                  end
       warn =
@@ -346,39 +346,52 @@ class OllamaChat::FollowChat
     end
   end
 
-  # The eval_stats method processes response statistics and formats them into a
-  # colored, readable string output.
+  # Extracts performance statistics from an Ollama response and formats them
+  # into a hash of human-readable strings and metrics.
   #
-  # @param response [ Object ] the response object containing evaluation metrics
-  #
-  # @return [ String ] a formatted string with statistical information about
-  #   the evaluation process including durations, counts, and rates, styled
-  #   with colors and formatting
-  def eval_stats(response)
+  # @param response [Object] the response object containing evaluation metrics
+  # @return [Hash] a hash of formatted statistics including durations, counts, and rates
+  def stats_hash(response)
     eval_duration        = response.eval_duration.to_f / 1e9
     prompt_eval_duration = response.prompt_eval_duration.to_f / 1e9
-    stats_text = {
-      eval_duration:        Tins::Duration.new(eval_duration),
+    {
+      eval_duration:        Tins::Duration.new(eval_duration).to_s,
       eval_count:           response.eval_count.to_i,
-      eval_rate:            bold { "%.2f t/s" % (response.eval_count.to_i / eval_duration) } + color(111),
-      prompt_eval_duration: Tins::Duration.new(prompt_eval_duration),
+      eval_rate:            "%.2f t/s" % (response.eval_count.to_i / eval_duration),
+      prompt_eval_duration: Tins::Duration.new(prompt_eval_duration).to_s,
       prompt_eval_count:    response.prompt_eval_count.to_i,
-      prompt_eval_rate:     bold { "%.2f t/s" % (response.prompt_eval_count.to_i / prompt_eval_duration) } + color(111),
-      total_duration:       Tins::Duration.new(response.total_duration / 1e9),
-      load_duration:        Tins::Duration.new(response.load_duration / 1e9),
-    }.map { _1 * ?= } * ' '
+      prompt_eval_rate:     "%.2f t/s" % (response.prompt_eval_count.to_i / prompt_eval_duration),
+      total_duration:       Tins::Duration.new(response.total_duration / 1e9).to_s,
+      load_duration:        Tins::Duration.new(response.load_duration / 1e9).to_s,
+    }
+  end
+
+  # The eval_stats method processes a statistics hash and formats it into a
+  # colored, readable string output.
+  #
+  # @param stats [Hash] the statistics hash containing evaluation metrics
+  #
+  # @return [String] a formatted string with statistical information about
+  #   the evaluation process including durations, counts, and rates, styled
+  #   with colors and formatting
+  def eval_stats(stats)
+    stats_text = stats.
+      deep_transform(value: -> idx, v { idx =~ /_rate\z/ ? bold(v) + color(111) : v }).
+      map { _1 * ?= } * ' '
     '📊 ' + color(111) {
       Kramdown::ANSI::Width.wrap(stats_text, percentage: 90).gsub(/(?<!\A)^/, '   ')
     }
   end
 
-  # The output_eval_stats method outputs evaluation statistics to the specified
-  # output stream.
+  # The output_eval_stats method extracts performance statistics from the response,
+  # logs them to the chat history, and prints a formatted summary to the terminal.
   #
-  # @param response [ Object ] the response object containing evaluation data
+  # @param response [Object] the response object containing evaluation data
   def output_eval_stats(response)
     response.done or return
-    @output.puts "", eval_stats(response)
+    stats = stats_hash(response)
+    chat.log(:info, 'Ollama chat response received', data: { stats: })
+    @output.puts "", eval_stats(stats)
   end
 
   # The debug_output method conditionally outputs the response object using jj

data/lib/ollama_chat/history.rb

@@ -81,6 +81,7 @@ module OllamaChat::History
         read_io(input:).to_a
       Reline::HISTORY.clear
       Reline::HISTORY.push(*history_data)
+      log(:info, "History initialized", data: { entries: history_data.size })
     end
   end
 
@@ -96,6 +97,7 @@ module OllamaChat::History
       OllamaChat::Utils::JSONJSONLIO.new('as.jsonl').
         write_io(output:, collection: Reline::HISTORY)
       session.history = output.string
+      log(:info, "History saved", data: { entries: Reline::HISTORY.size })
     end
   end
 
@@ -113,6 +115,7 @@ module OllamaChat::History
       Reline::HISTORY.clear
     ensure
       save_history
+      log(:info, "History cleared")
     end
   end
 end

data/lib/ollama_chat/logging.rb

@@ -31,15 +31,36 @@ module OllamaChat::Logging
     payload = {
       msg:   ,
       data:  data || {}
-    }
+    }.symbolize_keys_recursive
 
     if msg.is_a?(Exception)
+      if backtrace = msg.ask_and_send(:backtrace)
+        payload[:data][:backtrace] = backtrace
+      end
       payload[:msg] = msg = "#{msg.class}: #{msg.message}"
-      payload[:data][:backtrace] = msg.ask_and_send(:backtrace)
     else
-      payload[:msg] = msg.to_s
+      payload[:msg] = msg = msg.to_s
     end
 
+    # Sanitize payload for safe JSON serialization: break circular references
+    # and coerce non-serializable objects to strings while preserving
+    # primitives/hashes/arrays
+    payload = payload.deep_transform(
+      circular: ?…,
+      value: -> node {
+        keep = [
+          responding?(:to_hash), responding?(:to_ary), responding?(:to_int),
+          true, false, nil,
+        ]
+        case node
+        when *keep
+          node
+        else
+          node.to_s
+        end
+      }
+    )
+
     logger.send(severity, payload)
     warn and self.warn(msg)
     nil

data/lib/ollama_chat/message_list.rb

@@ -204,6 +204,17 @@ class OllamaChat::MessageList
     end
   end
 
+  # Cleans the messages in the list by replacing them with stripped versions.
+  # This is a destructive (mutating) operation.
+  #
+  # @param messages [Array<OllamaChat::Message>] the messages to clean.
+  #   Defaults to all current messages.
+  # @return [OllamaChat::MessageList] self to allow for method chaining.
+  def clean_messages!(messages: @messages)
+    @messages = clean_messages(messages:)
+    self
+  end
+
   # Displays the most recent messages from the conversation history.
   #
   # This method prints a specified number of trailing messages to the console

data/lib/ollama_chat/model_handling.rb

@@ -342,6 +342,7 @@ module OllamaChat::ModelHandling
 
     old_model != @model and reconfigure_model_options(profile:, keep_options:)
 
+    log(:info, "Model switched", data: { old_model:, new_model: @model, profile: })
     @model_metadata
   end
 

data/lib/ollama_chat/prompt_handling.rb

@@ -88,7 +88,11 @@ module OllamaChat::PromptHandling
     patterns = Array(patterns.full? || '**/*.{txt,md}')
     filename = choose_filename(patterns)
 
-    filename.read if filename&.exist?
+    content = filename.read if filename&.exist?
+    log(:info, "Prompt loaded from file", data: {
+      file: filename&.to_s, bytes: content&.size
+    })
+    content
   end
 
 

data/lib/ollama_chat/prompt_management.rb

@@ -92,7 +92,8 @@ module OllamaChat::PromptManagement
                 end
 
       prompt_content = edit_text(content)
-      store_prompt(name, prompt_content, context:).to_s
+      store_prompt(name, prompt_content, context:)
+      log(:info, "Prompt added", data: { name:, context: })
       true
     end
   end
@@ -114,6 +115,7 @@ module OllamaChat::PromptManagement
       yes: /\Ay/i
     ) or return
     selected_prompt.destroy
+    log(:info, "Prompt deleted", data: { name: selected_prompt.name, context: })
   end
 
   # Interactively selects an existing prompt and allows the user to edit its
@@ -125,6 +127,7 @@ module OllamaChat::PromptManagement
     selected_prompt = choose_prompt(context:, prompt: 'Which spell needs some fine-tuning? %s') or return
     selected_prompt.metadata['content'] = edit_text(selected_prompt.metadata['content'].to_s)
     selected_prompt.save
+    log(:info, "Prompt edited", data: { name: selected_prompt.name, context: })
     self
   end
 
@@ -164,6 +167,7 @@ module OllamaChat::PromptManagement
     duplicated_prompt.name = name
     duplicated_prompt.metadata['default'] = false
     duplicated_prompt.save
+    log(:info, "Prompt duplicated", data: { name:, old_name: selected_prompt.name, context: })
     self
   end
 
@@ -197,6 +201,7 @@ module OllamaChat::PromptManagement
     prompt_name = determine_valid_new_name_for_prompt('to import', context:) or return
     prompt_content = filename.read
     store_prompt(prompt_name, prompt_content, context:)
+    log(:info, "Prompt imported", data: { name: prompt_name, source: filename.to_s, context: })
     STDOUT.puts "Imported prompt as #{prompt_name.inspect}."
     self
   end
@@ -220,6 +225,7 @@ module OllamaChat::PromptManagement
     )
     filename = determine_valid_output_filename('to write to') or return
     filename.write(selected_prompt.to_s)
+    log(:info, "Prompt exported", data: { name: selected_prompt.name, dest: filename.to_s, context: })
     STDOUT.puts "Prompt #{selected_prompt.name.inspect} was exported as #{filename.to_path.inspect}?"
     self
   end