Module: OllamaChat::Information

Extended by:
Tins::Concern
Included in:
Chat
Defined in:
lib/ollama_chat/information.rb

Overview

A module that provides information and user agent functionality for OllamaChat

The Information module encapsulates methods for managing application identification, displaying version and configuration details, and providing a modular information dashboard for chat sessions. It includes user agent capabilities for HTTP requests and provides focused information views.

Examples:

Displaying application information

chat.info

Showing version details

chat.version

Displaying usage help

chat.usage

Defined Under Namespace

Modules: UserAgent

Instance Method Summary collapse

Instance Method Details

#client ⇒ String

The client method returns the application name and its current version as a single string

Returns:

  • (String) —

    the progname followed by the OllamaChat version separated by a space



62
63
64
 
# File 'lib/ollama_chat/information.rb', line 62

def client
  [ progname, OllamaChat::VERSION ] * ' '
end

#collection_descriptions ⇒ Hash{String => String}

Retrieves a hash of collection names and their descriptions from the database.

This is used to provide context to the AI model about available RAG collections.

Returns:

  • (Hash{String => String}) —

    a hash mapping collection names to their descriptions



313
314
315
316
317
318
319
 
# File 'lib/ollama_chat/information.rb', line 313

def collection_descriptions
  cols = models::Collection.where(enabled: true)
    .select(:name, :description).order(:name)
  cols.each_with_object({}) do |c, hash|
    hash[c.name] = c.description
  end
end

#collection_stats(output: STDOUT) ⇒ Object

The collection_stats method displays statistics about the current document collection.

This method outputs information regarding the active document collection, including the collection name, total number of embeddings, and a list of tags.

Parameters:

  • output (IO) (defaults to: STDOUT) —

    the output stream to write the message to



74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
 
# File 'lib/ollama_chat/information.rb', line 74

def collection_stats(output: STDOUT)
  col          = database_collection?(collection)
  length       = (Tins::Terminal.cols - 10).clamp(0..)
  wrapped_tags = Kramdown::ANSI::Width.
    wrap(@documents.tags.to_a.join(', '), length:).
    gsub(/(?<!\A)^/, ' ' * 4)
  output.puts <<~EOT
    Current Collection
      Name: #{bold{collection}}
      Status: #{col&.enabled ? '✅' : '⛔'}
      Patterns: #{italic{col&.patterns&.join(' ')}}
      #Embeddings: #{@documents.size}
      #Tags: #{@documents.tags.size}
      Tags:
        #{wrapped_tags}
  EOT
  nil
end

#context_filled ⇒ Float

Computes the fraction of the context window currently in use.

Divides the estimated token count of the session's messages by the effective context length, clamped to the range 0.0–1.0.

Returns:

  • (Float) —

    the ratio of used context (e.g. 0.73 for 73%)



424
425
426
427
 
# File 'lib/ollama_chat/information.rb', line 424

def context_filled
  es = messages.compacted_estimate_tokens
  (es.tokens.to_f / current_context_length).clamp(0..1).to_f
end

#context_gauge(percent_string) ⇒ String

Wraps a percentage string in an ANSI color based on context usage relative to compaction thresholds.

Green: below keep_recent budget — plenty of room. Yellow: between keep_recent and reserve — getting tight. Red: above reserve — compaction imminent.

Falls back to bold if context length is unknown.

Parameters:

  • percent_string (String) —

    the formatted percentage to colorize

Returns:

  • (String) —

    the ANSI-colored percentage string



457
458
459
460
461
462
463
464
465
466
467
468
469
470
471
472
473
 
# File 'lib/ollama_chat/information.rb', line 457

def context_gauge(percent_string)
  tokens = messages.compacted_estimate_tokens.tokens
  ctx    = current_context_length
  return bold { percent_string } unless ctx

  keep_recent = compact_ratio_tokens(:keep_recent, ctx)
  reserve     = compact_ratio_tokens(:reserve, ctx)
  bold do
    if tokens < keep_recent
      '🟢 ' + green { percent_string }
    elsif tokens <= reserve
      '🟡 ' + yellow { percent_string }
    else
      '🔴 ' + red { percent_string }
    end
  end
end

#context_usage ⇒ String?

Formats the current context usage as a human-readable string.

Returns a string like "167.7 KT of 262.1 KT (64.0%)" combining the estimated tokens in use, the effective context length, and the percentage (via context_filled).

Returns:

  • (String, nil) —

    the formatted usage string, or nil if the context length cannot be determined.



437
438
439
440
441
442
443
444
445
 
# File 'lib/ollama_chat/information.rb', line 437

def context_usage
  if cl = current_context_length
    '%s of %s (%s)' % [
      messages.compacted_estimate_tokens.tokens_formatted,
      format_tokens(current_context_length),
      '%.1f%%' % (100 * context_filled),
    ]
  end
end

#conversation_length ⇒ String

Returns a formatted string representing the estimated text length of the full stored conversation, excluding images and JSON scaffolding.

Delegates to MessageList#full_estimate_tokens, which sums per-message token_estimate (content + optional thinking) across all messages, respecting the think_strip toggle. This differs from Session#estimate_tokens, which measures raw JSONL bytes including base64 images and metadata — the latter is the storage footprint, this is the model-facing text volume.

Returns:

  • (String) —

    formatted as "340.5 KT (1.2 MiB)"



361
362
363
364
 
# File 'lib/ollama_chat/information.rb', line 361

def conversation_length
  es = messages.full_estimate_tokens
  "%s (%s)" % [ es.tokens_formatted, es.bytes_formatted ]
end

#current_context_length ⇒ Integer, NilClass

Resolves the effective context window size for the current model.

Prefers the session-level num_ctx override (set via /model_options or the stored model options profile). Falls back to the model's native context_length in the default profile or as reported by the Ollama server if possible.

Returns:

  • (Integer, NilClass) —

    the context length in tokens or nil



412
413
414
415
416
 
# File 'lib/ollama_chat/information.rb', line 412

def current_context_length
  get_session_model_options[:num_ctx] ||
  get_stored_model_options(@model)[:num_ctx] ||
    ollama.ps&.models&.find { _1.name == @model }&.context_length
end

#display_chat_help(pattern = nil) ⇒ Object

The display_chat_help method outputs the chat help message to standard output, eventually using the configured pager.

Parameters:

  • pattern (String, Regexp, nil) (defaults to: nil) —

    An optional pattern to filter the commands displayed in the help message.



228
229
230
231
232
233
 
# File 'lib/ollama_chat/information.rb', line 228

def display_chat_help(pattern = nil)
  use_pager do |output|
    output.puts help_message(pattern)
  end
  nil
end

#dynamic_runtime_information ⇒ String

The dynamic_runtime_information method generates a formatted string containing real-time environment details (the "heartbeat").

It returns the result of interpolating the dynamic values into the configured dynamic_runtime_info prompt template.

Returns:

  • (String) —

    the formatted dynamic runtime information string.



400
401
402
 
# File 'lib/ollama_chat/information.rb', line 400

def dynamic_runtime_information
  prompt(:dynamic_runtime_info).to_s % dynamic_runtime_information_values
end

#dynamic_runtime_information_values ⇒ Hash

The dynamic_runtime_information_values method compiles a set of volatile runtime details that change frequently.

These include the current timestamp, weekday, session name, git branch and origin, terminal dimensions, and feature switch statuses.

Returns:

  • (Hash) —

    a hash containing dynamic runtime values.



373
374
375
376
377
378
379
380
381
382
383
384
385
386
387
388
389
390
391
 
# File 'lib/ollama_chat/information.rb', line 373

def dynamic_runtime_information_values
  now = Time.now
  {
    git_current_branch:   `git rev-parse --abbrev-ref HEAD 2>/dev/null`.chomp.full? || 'n/a',
    git_remote_origin:    `git remote get-url origin 2>/dev/null`.chomp.full? || 'n/a',
    git_sha:              `git rev-parse HEAD 2>/dev/null`.chomp.full? || 'n/a',
    git_sha_short:        `git rev-parse --short HEAD 2>/dev/null`.chomp.full? || 'n/a',
    markdown:             markdown.on? ? 'enabled' : 'disabled',
    session_name:         session.name,
    terminal_cols:        Tins::Terminal.cols,
    terminal_rows:        Tins::Terminal.rows,
    time:                 now.iso8601,
    tools_support:        tools_support.on? ? 'enabled' : 'disabled',
    voice:                voice.on? ? 'enabled' : 'disabled',
    weekday:              now.strftime('%A'),
    context_usage:        ,
    conversation_length:  ,
  }
end

#info(output: STDOUT) ⇒ Object

Displays a high-level summary dashboard of the current state of the ollama_chat instance.

Parameters:

  • output (IO) (defaults to: STDOUT) —

    the output stream to write the information to, defaults to STDOUT



206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
 
# File 'lib/ollama_chat/information.rb', line 206

def info(output: STDOUT)
  print_welcome(output:)
  output.puts "📜 Documents database cache is #{@documents.nil? ? 'n/a' : bold{@documents.cache.class}}"
  output.puts "🔎 Currently selected search engine is #{bold{search_engine}}."
  output.puts "🧠 Current chat model is #{bold{@model}}."
  output.puts "🗣️ Session: #{bold{@session.name}} (#{italic{@session.id}})"
  output.puts "  Current System Prompt: #{bold{current_system_prompt_name}}"
  if name = default_persona_name
    output.puts "  💃 Persona: #{bold{name}}"
  else
    output.puts "  No persona selected."
  end
  output.print '  🛠️ '; tools_support.show(output:)
  output.print '  🏃 '; runtime_info.show(output:)
  nil
end

#info_model(output: STDOUT) ⇒ Object

Displays detailed information about the current chat model, including capabilities, families, and configuration options.

Parameters:

  • output (IO) (defaults to: STDOUT) —

    the output stream to print the model information to (defaults to STDOUT).



98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
 
# File 'lib/ollama_chat/information.rb', line 98

def info_model(output: STDOUT)
  output.puts "🧠 Current chat model is #{bold{@model}}."
  output.puts   "  Capabilities: #{Array(@model_metadata&.capabilities) * ', '}"
  output.puts   "  Families: #{Array(@model_metadata&.families) * ', '}"

  profiles = models::ModelOptions.where(model_name: @model).order(:profile).all
  if profiles.full?
    output.puts "  Stored Profile Options:"
    profiles.each do |p|
      output.puts <<~EOT.gsub(/^/, '      ')
        #{bold{p.profile}}:
          #{JSON.pretty_generate(p.options)}
      EOT
    end
  elsif config.model.options.full?
    output.puts "  Default Options: #{JSON.pretty_generate(mo).gsub(/(?<!\A)^/, '  ')}"
  end

  if model_options.present?
    output.puts "  Session Options: #{JSON.pretty_generate(model_options).gsub(/(?<!\A)^/, '  ')}"
  end
end

#info_rag(output: STDOUT) ⇒ Object

Displays information regarding the Retrieval Augmented Generation (RAG) configuration, including the embedding model and collection statistics.

Parameters:

  • output (IO) (defaults to: STDOUT) —

    the output stream to write the information to, defaults to STDOUT



177
178
179
180
181
182
183
184
185
186
187
188
 
# File 'lib/ollama_chat/information.rb', line 177

def info_rag(output: STDOUT)
  if @embedding.on?
    output.puts "🗄️ Current RAG model is #{bold{@embedding_model}}"
    if @embedding_model_options.present?
      output.puts "  Options: #{JSON.pretty_generate(@embedding_model_options).gsub(/(?<!\A)^/, '  ')}"
    end
    output.puts "Text splitter is #{bold{config.embedding.splitter.name}}."
    collection_stats(output:)
  end
  @embedding.show(output:)
  output.puts "📜 Document policy for parsing in user text: #{bold{document_policy}}"
end

#info_runtime(output: STDOUT) ⇒ Object

Displays the current runtime environment details, split into static (session-level) and dynamic (real-time) information.

Parameters:

  • output (IO) (defaults to: STDOUT) —

    the output stream to write the information to, defaults to STDOUT



162
163
164
165
166
167
168
169
170
171
 
# File 'lib/ollama_chat/information.rb', line 162

def info_runtime(output: STDOUT)
  output.puts "🏃 Runtime Information:"
  output.print '  '; runtime_info.show(output:)
  output.puts 'Static:'
  output.puts static_runtime_information_values.stringify_keys_recursive.to_yaml.
    sub(/\A---\s*\n/, '').gsub(/^/, '  ')
  output.puts 'Dynamic:'
  output.puts dynamic_runtime_information_values.stringify_keys_recursive.to_yaml.
    sub(/\A---\s*\n/, '').gsub(/^/, '  ')
end

#info_session(output: STDOUT) ⇒ Object

Displays a detailed view of the current chat session state, including the system prompt, persona, active model, thinking modes, tools, and audio settings.

Parameters:

  • output (IO) (defaults to: STDOUT) —

    the output stream to write the information to, defaults to STDOUT



126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
 
# File 'lib/ollama_chat/information.rb', line 126

def info_session(output: STDOUT)
  output.print "🗣️ Current session: "; show_session(output:)
  output.puts "  Current Session Working Directory: \"#{bold{session.working_directory}}\""
  output.puts "  Current System Prompt: #{bold{current_system_prompt_name}}"
  if name = default_persona_name
    output.puts "  💃 Persona: #{bold{name}}"
  else
    output.puts "  No persona selected."
  end
  output.puts "🧠 Current chat model is #{bold{@model}}."
  context_usage = '%s of %s (%s)' % [
    messages.compacted_estimate_tokens.tokens_formatted,
    format_tokens(current_context_length),
    context_gauge(format('%.1f%%', 100 * context_filled)),
  ]
  output.puts  "  Context Usage: #{context_usage}"
  output.puts  "  Conversation Length: #{conversation_length}"
  output.print '  '; think_mode.show(output:)
  output.print '  '; think_loud.show(output:)
  output.print '  '; think_strip.show(output:)
  output.print '  🛠️ '; tools_support.show(output:)
  output.print "\u2699\uFE0F Chat Settings"
  output.print '  '; markdown.show(output:)
  output.print '  '; stream.show(output:)
  output.print '  🎙️ '; voice.show(output:)
  if voice.on?
    output.print '  '; voices.show(output:)
  end
  output.print '  '; location.show(output:)
  output.print '  '; context_format.show(output:)
end

#infobar_message ⇒ Hash

Returns the infobar message configuration as a hash.

This configuration is used by the infobar gem to define the progress bar's format and spinner settings.

Returns:

  • (Hash) —

    the infobar message configuration



301
302
303
 
# File 'lib/ollama_chat/information.rb', line 301

def infobar_message
  config.infobar.message.to_h
end

#print_welcome(output: STDOUT) ⇒ Object

The print_welcome method prints a welcome message containing the application version, the connected ollama server version, and the server URL.

Parameters:

  • output (IO) (defaults to: STDOUT) —

    the output stream where the welcome messages are printed (default: STDOUT)



196
197
198
199
 
# File 'lib/ollama_chat/information.rb', line 196

def print_welcome(output: STDOUT)
  output.puts "💎 Running ollama_chat version: #{bold{OllamaChat::VERSION}}"
  output.puts "🔌 Connected to ollama server version: #{bold{server_version}} on: #{bold{server_url}}"
end

#server_url ⇒ String

The server_url method returns the base URL of the Ollama server connection.

Returns:

  • (String) —

    the base URL used for communicating with the Ollama API



277
278
279
 
# File 'lib/ollama_chat/information.rb', line 277

def server_url
  @server_url ||= ollama.base_url
end

#server_version ⇒ String

The server_version method retrieves the version of the Ollama server.

Returns:

  • (String) —

    the version string of the connected Ollama server



270
271
272
 
# File 'lib/ollama_chat/information.rb', line 270

def server_version
  @server_version ||= ollama.version.version
end

#static_runtime_information ⇒ String

Generates a formatted string of static runtime information.

This method interpolates the static runtime values into the configured static_runtime_info prompt template.

Returns:

  • (String) —

    a formatted static runtime information string.



346
347
348
 
# File 'lib/ollama_chat/information.rb', line 346

def static_runtime_information
  prompt(:static_runtime_info).to_s % static_runtime_information_values
end

#static_runtime_information_values ⇒ Hash

Generates a hash containing static runtime information.

This method collects session-level constants including the user, language preferences, location, client version, working directory, allowed tool paths, and available RAG collections.

Returns:

  • (Hash) —

    a hash containing static runtime data.



328
329
330
331
332
333
334
335
336
337
338
 
# File 'lib/ollama_chat/information.rb', line 328

def static_runtime_information_values
  {
    client:               ,
    collections:          JSON.pretty_generate(collection_descriptions),
    current_directory:    Pathname.pwd.expand_path.to_path,
    languages:            config.languages * ', ',
    location:             location.on?.full? { location_description } || 'n/a',
    tool_paths_allowed:   JSON.pretty_generate(tool_paths_allowed),
    user:                 ,
  }
end

#usage ⇒ Integer

The usage method displays the command-line idea help text and returns an exit code of 0.

Returns:

  • (Integer) —

    always returns 0 indicating successful help display



239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
 
# File 'lib/ollama_chat/information.rb', line 239

def usage
  STDOUT.puts <<~EOT
    Usage: #{progname} [OPTIONS]

      -f CONFIG      config file to read
      -l SESSION     load session with name/id SESSION
      -n             create a new session
      -u URL         the ollama base url, OLLAMA_URL
      -m MODEL       the ollama chat model, OLLAMA_CHAT_MODEL, ?selector
      -S             open a socket to receive input from ollama_chat_send
      -V             display the current version number and quit
      -h             this help

      Use `?selector` with `-m` or `-l` to filter options. Multiple matches
      will open a chooser dialog.
  EOT
  0
end

#user ⇒ String

Retrieves the name of the chat user.

Returns:

  • (String) —

    the chat user's name or 'n/a' if not set



284
285
286
 
# File 'lib/ollama_chat/information.rb', line 284

def user
  user_name || 'n/a'
end

#user_name ⇒ String

Retrieves the name of the chat user.

Returns:

  • (String) —

    the chat user's name or nil if not set



291
292
293
 
# File 'lib/ollama_chat/information.rb', line 291

def user_name
  OC::OLLAMA::CHAT::USER
end

#version ⇒ Integer

The version method outputs the program name and its version number to standard output.

Returns:

  • (Integer) —

    returns 0 indicating successful execution



262
263
264
265
 
# File 'lib/ollama_chat/information.rb', line 262

def version
  STDOUT.puts "%s %s" % [ progname, OllamaChat::VERSION ]
  0
end