Class: Rubino::Config::Configuration

Inherits:
Object
  • Object
show all
Defined in:
lib/rubino/config/configuration.rb

Overview

Central configuration object providing typed accessors for all config sections. Wraps the raw hash loaded by Config::Loader with convenient method access.

Instance Attribute Summary collapse

Instance Method Summary collapse

Constructor Details

#initialize(raw: nil, home_path: nil) ⇒ Configuration

Returns a new instance of Configuration.



10
11
12
13
 
# File 'lib/rubino/config/configuration.rb', line 10

def initialize(raw: nil, home_path: nil)
  @home_path = home_path
  @raw = raw || load_from_file
end

Instance Attribute Details

#raw ⇒ Object (readonly)

Returns the value of attribute raw.



8
9
10
 
# File 'lib/rubino/config/configuration.rb', line 8

def raw
  @raw
end

Instance Method Details

#agent_budget_extension_prompt? ⇒ Boolean

At the iteration cap, prompt to continue/summarize/abort (#399). Defaults to true; an explicit false forces the old always-summarize behaviour. Independent of TTY — the headless guarantee lives in @ui.select returning nil, not here.

Returns:

  • (Boolean) 


146
147
148
149
 
# File 'lib/rubino/config/configuration.rb', line 146

def agent_budget_extension_prompt?
  v = dig("agent", "budget_extension_prompt")
  v.nil? ? Defaults.dig("agent", "budget_extension_prompt") : v == true
end

#agent_budget_extension_step ⇒ Object

The “+N” one budget extension grants. nil/blank ⇒ max_tool_iterations, so an extension doubles the per-turn runway (the Cline/Roo “reset the counter, keep context” amount). Coerced to a positive Integer; a bad value falls back to the iteration cap.



155
156
157
158
159
 
# File 'lib/rubino/config/configuration.rb', line 155

def agent_budget_extension_step
  raw = dig("agent", "budget_extension_step")
  n = Integer(raw, exception: false)
  n&.positive? ? n : agent_max_tool_iterations
end

#agent_disabled_toolsets ⇒ Object 



161
162
163
 
# File 'lib/rubino/config/configuration.rb', line 161

def agent_disabled_toolsets
  dig("agent", "disabled_toolsets") || []
end

#agent_max_tool_iterations ⇒ Object

– Agent section – Iteration/time caps fall back to the built-in defaults when the config value is nil/missing (e.g. ‘config set agent.max_tool_iterations nil`, whose writer coerces “nil” -> nil). A bare nil here would crash every turn in IterationBudget’s numeric comparisons (#139).



134
135
136
 
# File 'lib/rubino/config/configuration.rb', line 134

def agent_max_tool_iterations
  dig("agent", "max_tool_iterations") || Defaults.dig("agent", "max_tool_iterations")
end

#agent_max_turn_seconds ⇒ Object 



138
139
140
 
# File 'lib/rubino/config/configuration.rb', line 138

def agent_max_turn_seconds
  dig("agent", "max_turn_seconds") || Defaults.dig("agent", "max_turn_seconds")
end

#api_allow_public_bind? ⇒ Boolean

– API section – Whether the HTTP API server may bind to a non-loopback address. SAFE BY DEFAULT (#577): false REFUSES a routable bind (the API runs shell tools); set true to deliberately publish the listener (use TLS + a strong key).

Returns:

  • (Boolean) 


455
456
457
 
# File 'lib/rubino/config/configuration.rb', line 455

def api_allow_public_bind?
  dig("api", "allow_public_bind") == true
end

#approvals_readonly_commands ⇒ Object

Extra command names / leading-token prefixes merged into the built-in read-only set (Security::ReadonlyCommands::SAFE_COMMANDS).



388
389
390
 
# File 'lib/rubino/config/configuration.rb', line 388

def approvals_readonly_commands
  dig("approvals", "readonly_commands") || []
end

#approvals_wait_timeout ⇒ Object

– Security section – Seconds a run blocks on a human approval/clarification before the gate gives up and AUTO-DENIES (freeing the worker thread). nil = wait indefinitely (interruptible only by an explicit stop). Used by ApprovalGate as its default await deadline so an abandoned approval never parks a server worker for the whole window (W1).



372
373
374
375
376
377
 
# File 'lib/rubino/config/configuration.rb', line 372

def approvals_wait_timeout
  raw = dig("approvals", "wait_timeout_seconds")
  return nil if raw.nil?

  raw.to_f
end

#auto_allow_readonly? ⇒ Boolean

Auto-allow provably read-only shell commands (ls, cat, grep, git log, …) without an approval prompt. Default ON (key absent = on); the hardline floor and permissions:deny still precede it.

Returns:

  • (Boolean) 


382
383
384
 
# File 'lib/rubino/config/configuration.rb', line 382

def auto_allow_readonly?
  dig("approvals", "auto_allow_readonly") != false
end

#auxiliary_config(task) ⇒ Object

Generic accessor for auxiliary task config blocks. Returns {} when the task isn’t defined, so callers can chain .dig safely.



436
437
438
 
# File 'lib/rubino/config/configuration.rb', line 436

def auxiliary_config(task)
  dig("auxiliary", task.to_s) || {}
end

#auxiliary_vision_config ⇒ Object

– Auxiliary section –



430
431
432
 
# File 'lib/rubino/config/configuration.rb', line 430

def auxiliary_vision_config
  dig("auxiliary", "vision") || {}
end

#clarify_timeout ⇒ Object

Bound (seconds) an interactive ‘question`/clarify waits for the human to answer before it EXPIRES CLEANLY and the agent proceeds with its best judgement (#552). Mirrors the ask_parent / Hermes clarify_timeout convention — a generous upper bound (default 600s = 10 min, well above human reading/deliberation time), never the 30s stale-chunk window and never “forever”. An abandoned clarify self-heals into the NO_ANSWER outcome instead of hanging the run or being killed by the stale watchdog.



210
211
212
 
# File 'lib/rubino/config/configuration.rb', line 210

def clarify_timeout
  dig("clarify", "timeout") || Defaults.dig("clarify", "timeout")
end

#compression_enabled? ⇒ Boolean

– Compression section –

Returns:

  • (Boolean) 


258
259
260
 
# File 'lib/rubino/config/configuration.rb', line 258

def compression_enabled?
  dig("compression", "enabled") == true
end

#compression_preserve_tool_pairs? ⇒ Boolean

Returns:

  • (Boolean) 


262
263
264
 
# File 'lib/rubino/config/configuration.rb', line 262

def compression_preserve_tool_pairs?
  dig("compression", "preserve_tool_pairs") == true
end

#confirm_policy ⇒ Object

Effective shell prompt policy and SOLE source of truth (item 7): the legacy security.require_confirmation_for_shell alias was REMOVED — no back-compat mapping. :dangerous_only (DEFAULT — safe shell commands run unprompted; only DangerousPatterns matches prompt) or :confirm_all (every not-otherwise-allowed shell command prompts). An unset or unrecognized value falls back to the seeded :dangerous_only default. A config that still carries the removed key is NOT silently honored — Validator.warnings flags it at load + in ‘rubino doctor`.



400
401
402
403
404
405
 
# File 'lib/rubino/config/configuration.rb', line 400

def confirm_policy
  raw = dig("security", "confirm_policy")
  return raw.to_sym if %w[confirm_all dangerous_only].include?(raw.to_s)

  :dangerous_only
end

#database_path ⇒ Object

– Database section – Resolves the sqlite path. The DEFAULT (sentinel) follows the resolved home so RUBINO_HOME relocates the DB alongside config/.env/skills, avoiding the split brain where config went to the isolated home but the DB to the real ~/.rubino (issue #96). An EXPLICIT database.path in config.yml wins and is expanded verbatim.



21
22
23
24
25
26
27
28
 
# File 'lib/rubino/config/configuration.rb', line 21

def database_path
  path = dig("database", "path")
  if path == Defaults::DEFAULT_DATABASE_PATH
    File.join(resolved_home, "rubino.sqlite3")
  else
    File.expand_path(path)
  end
end

#dig(*keys) ⇒ Object

– Generic access –



460
461
462
 
# File 'lib/rubino/config/configuration.rb', line 460

def dig(*keys)
  @raw.dig(*keys)
end

#display_input_max_rows ⇒ Object

Cap on the chat input’s visual rows (display.input_max_rows). Falls back to the composer default for nil/zero/garbage so a bad value can never collapse or unbound the input block.



58
59
60
61
 
# File 'lib/rubino/config/configuration.rb', line 58

def display_input_max_rows
  value = dig("display", "input_max_rows").to_i
  value.positive? ? value : UI::BottomComposer::MAX_INPUT_ROWS
end

#display_statusbar? ⇒ Boolean

The status bar under the chat input (display.statusbar, default true). Only an explicit false disables it.

Returns:

  • (Boolean) 


42
43
44
 
# File 'lib/rubino/config/configuration.rb', line 42

def display_statusbar?
  dig("display", "statusbar") != false
end

#display_streaming? ⇒ Boolean

– Display section –

Returns:

  • (Boolean) 


36
37
38
 
# File 'lib/rubino/config/configuration.rb', line 36

def display_streaming?
  dig("display", "streaming") == true
end

#display_tool_output_preview_lines ⇒ Object

Transcript preview budget for tool output (display.tool_output_preview_lines): head lines shown before the “… +N lines (full output → context)” marker. 0 = no collapse (full dump). Display-only — the model-facing output is untouched.



50
51
52
53
 
# File 'lib/rubino/config/configuration.rb', line 50

def display_tool_output_preview_lines
  value = dig("display", "tool_output_preview_lines")
  value.nil? ? 3 : value.to_i
end

#doom_loop_hard_stop? ⇒ Boolean

– Doom-loop guard (#414) – Default WARN-not-block (hard_stop false): a tripped detector surfaces a warning to the model but does not deny the call.

Returns:

  • (Boolean) 


118
119
120
 
# File 'lib/rubino/config/configuration.rb', line 118

def doom_loop_hard_stop?
  dig("doom_loop", "hard_stop") == true
end

#doom_loop_threshold ⇒ Object

Identical-consecutive-call threshold. Falls back to the detector default when absent/garbage so a bad config value can’t disable the guard.



124
125
126
127
 
# File 'lib/rubino/config/configuration.rb', line 124

def doom_loop_threshold
  n = Integer(dig("doom_loop", "threshold"), exception: false)
  n && n >= 2 ? n : Security::DoomLoopDetector::DEFAULT_THRESHOLD
end

#memory_auto_extract? ⇒ Boolean

Returns:

  • (Boolean) 


271
272
273
 
# File 'lib/rubino/config/configuration.rb', line 271

def memory_auto_extract?
  dig("memory", "auto_extract") == true
end

#memory_auto_extract_interval ⇒ Object

Throttle interval (in turns) for memory.auto_extract (#412). Returns a positive Integer; nil/<=1 (or absent) ⇒ 1 = every turn. The lifecycle only enqueues ExtractMemoryJob when turns-since-last >= this.



286
287
288
 
# File 'lib/rubino/config/configuration.rb', line 286

def memory_auto_extract_interval
  positive_interval(dig("memory", "auto_extract_interval"))
end

#memory_auto_summarize? ⇒ Boolean

Background session-summary aux-LLM job (SummarizeSessionJob). Default ON (absent ⇒ true), so existing behaviour is unchanged; an explicit false turns it off — letting the whole background aux-LLM surface (extract/distill/summarize) be disabled together.

Returns:

  • (Boolean) 


279
280
281
 
# File 'lib/rubino/config/configuration.rb', line 279

def memory_auto_summarize?
  dig("memory", "auto_summarize") != false
end

#memory_enabled? ⇒ Boolean

– Memory section –

Returns:

  • (Boolean) 


267
268
269
 
# File 'lib/rubino/config/configuration.rb', line 267

def memory_enabled?
  dig("memory", "enabled") == true
end

#model_supports_vision? ⇒ Boolean

Returns true when the primary model can ingest images directly. Honours an explicit ‘model.supports_vision` override; otherwise falls back to ContentBuilder’s name-pattern heuristic. Used by VisionTool to decide whether to expose itself (no point delegating if the primary can see).

Returns:

  • (Boolean) 


444
445
446
447
448
449
 
# File 'lib/rubino/config/configuration.rb', line 444

def model_supports_vision?
  raw = dig("model", "supports_vision")
  return raw == true unless raw.nil?

  LLM::ContentBuilder.supports_vision?(dig("model", "default").to_s)
end

#notifications_bell? ⇒ Boolean

Returns:

  • (Boolean) 


96
97
98
 
# File 'lib/rubino/config/configuration.rb', line 96

def notifications_bell?
  dig("notifications", "bell") != false
end

#notifications_command ⇒ Object 



100
101
102
103
 
# File 'lib/rubino/config/configuration.rb', line 100

def notifications_command
  value = dig("notifications", "command").to_s
  value.empty? ? nil : value
end

#notifications_enabled? ⇒ Boolean

– Notifications section (UI::Notifier: attention bell + hook) – enabled/bell are on unless explicitly false; command is nil unless a non-empty string is set; min_turn_seconds falls back to the default.

Returns:

  • (Boolean) 


92
93
94
 
# File 'lib/rubino/config/configuration.rb', line 92

def notifications_enabled?
  dig("notifications", "enabled") != false
end

#notifications_min_turn_seconds ⇒ Object 



105
106
107
108
 
# File 'lib/rubino/config/configuration.rb', line 105

def notifications_min_turn_seconds
  value = dig("notifications", "min_turn_seconds")
  (value.nil? ? Defaults.dig("notifications", "min_turn_seconds") : value).to_f
end

#paste_collapse_chars ⇒ Object

A paste with MORE than this many CHARACTERS also collapses to a placeholder, even on a single line — a big one-line paste (a long token, URL, minified JSON) would otherwise flood the composer because the line-count trigger never fired. Falls back for nil/zero/garbage.



76
77
78
79
 
# File 'lib/rubino/config/configuration.rb', line 76

def paste_collapse_chars
  value = dig("paste", "collapse_chars").to_i
  value.positive? ? value : UI::PasteStore::DEFAULT_COLLAPSE_CHARS
end

#paste_collapse_lines ⇒ Object

– Paste section (UI::PasteStore: the file-backed paste pipeline) – A paste with MORE than this many lines collapses to a “[Pasted text #N +M lines]” placeholder in the composer (expanded to the full body at send). Falls back for nil/zero/garbage.



67
68
69
70
 
# File 'lib/rubino/config/configuration.rb', line 67

def paste_collapse_lines
  value = dig("paste", "collapse_lines").to_i
  value.positive? ? value : UI::PasteStore::DEFAULT_COLLAPSE_LINES
end

#paste_file_threshold_tokens ⇒ Object

A paste estimated above this many tokens (chars/4, the same rule compaction uses) overflows to <home>/sessions/<id>/paste_N.txt and the message carries a read-tool pointer instead of the content.



84
85
86
87
 
# File 'lib/rubino/config/configuration.rb', line 84

def paste_file_threshold_tokens
  value = dig("paste", "file_threshold_tokens").to_i
  value.positive? ? value : UI::PasteStore::DEFAULT_THRESHOLD_TOKENS
end

#prompts_environment_enabled? ⇒ Boolean

Returns:

  • (Boolean) 


225
226
227
228
229
230
 
# File 'lib/rubino/config/configuration.rb', line 225

def prompts_environment_enabled?
  # Default to on when the key is absent — env injection is the cheap
  # win we don't want a forgetful config.yml to disable accidentally.
  value = dig("prompts", "environment", "enabled")
  value.nil? || value == true
end

#prompts_environment_extra_utilities ⇒ Object 



232
233
234
 
# File 'lib/rubino/config/configuration.rb', line 232

def prompts_environment_extra_utilities
  Array(dig("prompts", "environment", "extra_utilities")).map(&:to_s)
end

#prompts_override_for(role) ⇒ Object

Returns the override string for a given role name, or nil if the built-in default prompt should be used.



238
239
240
241
242
243
244
 
# File 'lib/rubino/config/configuration.rb', line 238

def prompts_override_for(role)
  value = dig("prompts", "overrides", role.to_s)
  return nil if value.nil?

  text = value.to_s.strip
  text.empty? ? nil : text
end

#prompts_preamble ⇒ Object

– Prompts section – The customer-facing preamble prepended to every assembled system prompt. nil/empty disables the layer.



217
218
219
220
221
222
223
 
# File 'lib/rubino/config/configuration.rb', line 217

def prompts_preamble
  value = dig("prompts", "preamble")
  return nil if value.nil?

  text = value.to_s.strip
  text.empty? ? nil : text
end

#provider_config(name) ⇒ Object

– Providers section –



425
426
427
 
# File 'lib/rubino/config/configuration.rb', line 425

def provider_config(name)
  dig("providers", name.to_s) || {}
end

#reload! ⇒ Object 



473
474
475
 
# File 'lib/rubino/config/configuration.rb', line 473

def reload!
  @raw = load_from_file
end

#run_idle_event_timeout ⇒ Object

– Run lifecycle section – Returns Float seconds (or nil to disable). EventsOperation uses this to bound how long a “running” row can go without producing a new event before the watchdog promotes it to failed.



250
251
252
253
254
255
 
# File 'lib/rubino/config/configuration.rb', line 250

def run_idle_event_timeout
  raw = dig("run", "idle_event_timeout")
  return nil if raw.nil?

  raw.to_f
end

#security_command_allowlist ⇒ Object

The pre-approved command allowlist, always returned as an Array.

YAML lets a user write ‘command_allowlist: git status` (a scalar) where a sequence was meant. The matcher (CommandAllowlist#allowlist_token_lists) calls #filter_map on this value; a bare String would raise an unhandled NoMethodError out of the approval path (a crash, not the clean fail-closed contract — CFG-R3-1). Coerce a scalar to a single-entry array and drop any nil so the matcher always receives a well-formed list.



415
416
417
418
419
420
421
422
 
# File 'lib/rubino/config/configuration.rb', line 415

def security_command_allowlist
  raw = dig("security", "command_allowlist")
  case raw
  when Array then raw
  when nil then []
  else [raw]
  end
end

#set(*keys, value) ⇒ Object 



464
465
466
467
468
469
470
471
 
# File 'lib/rubino/config/configuration.rb', line 464

def set(*keys, value)
  hash = @raw
  keys[0..-2].each do |key|
    hash[key] ||= {}
    hash = hash[key]
  end
  hash[keys.last] = value
end

#skills_auto_distill? ⇒ Boolean

Post-turn skill distillation. Defaults to true (skills feature on + distill key absent ⇒ distill on), mirroring memory_auto_extract? as the gate for an aux-spending background job. Turning skills off disables it too, since there is no point distilling skills that won’t be loaded.

Returns:

  • (Boolean) 


294
295
296
297
298
299
 
# File 'lib/rubino/config/configuration.rb', line 294

def skills_auto_distill?
  return false unless dig("skills", "enabled") != false

  value = dig("skills", "auto_distill")
  value.nil? || value == true
end

#skills_auto_distill_interval ⇒ Object

Throttle interval (in turns) for skills.auto_distill (#414). Mirrors memory_auto_extract_interval. nil/<=1 ⇒ every eligible turn.



303
304
305
 
# File 'lib/rubino/config/configuration.rb', line 303

def skills_auto_distill_interval
  positive_interval(dig("skills", "auto_distill_interval"))
end

#streaming_enabled? ⇒ Boolean

– Streaming section –

Returns:

  • (Boolean) 


111
112
113
 
# File 'lib/rubino/config/configuration.rb', line 111

def streaming_enabled?
  dig("streaming", "enabled") == true
end

#tasks_ask_parent_timeout ⇒ Object

Bound (seconds) a BLOCKING ask_parent waits for an answer before the child self-heals and proceeds with its best judgement (S5a). Reuses the approval-gate timeout convention — a sane upper bound, never “forever” —so an abandoned ask never parks the child’s thread indefinitely. Default 900.



199
200
201
 
# File 'lib/rubino/config/configuration.rb', line 199

def tasks_ask_parent_timeout
  dig("tasks", "ask_parent_timeout") || Defaults.dig("tasks", "ask_parent_timeout")
end

#tasks_max_children_per_node ⇒ Object

Maximum number of LIVE direct children a single node (the human/top-level or one subagent) may have at once. Default 3.



177
178
179
 
# File 'lib/rubino/config/configuration.rb', line 177

def tasks_max_children_per_node
  dig("tasks", "max_children_per_node") || Defaults.dig("tasks", "max_children_per_node")
end

#tasks_max_concurrent_total ⇒ Object

Hard global ceiling on the total number of LIVE subagents across the whole tree, so depth × fan-out cannot blow past the process’s thread/cost budget. Default 8.



184
185
186
 
# File 'lib/rubino/config/configuration.rb', line 184

def tasks_max_concurrent_total
  dig("tasks", "max_concurrent_total") || Defaults.dig("tasks", "max_concurrent_total")
end

#tasks_max_depth ⇒ Object

– Tasks / nested-subagent caps – Maximum nesting depth for the ‘task` delegation tree. depth 0 is a human/top-level-spawned child; the cap bounds how deep a chain of subagents-spawning-subagents may go. Default 2 ⇒ human→child→grandchild. Falls back to the built-in default when missing/nil so the numeric caps in BackgroundTask#reserve never crash on a bare nil.



171
172
173
 
# File 'lib/rubino/config/configuration.rb', line 171

def tasks_max_depth
  dig("tasks", "max_depth") || Defaults.dig("tasks", "max_depth")
end

#tasks_max_live_probes_per_child ⇒ Object

Per-child budget for BILLED live probes (‘probe(live:true)`). Over budget, the model is steered to the FREE live:false snapshot. Free snapshots are unlimited. Default 5.



191
192
193
 
# File 'lib/rubino/config/configuration.rb', line 191

def tasks_max_live_probes_per_child
  dig("tasks", "max_live_probes_per_child") || Defaults.dig("tasks", "max_live_probes_per_child")
end

#tool_enabled?(name) ⇒ Boolean

– Tools section –

Returns:

  • (Boolean) 


308
309
310
 
# File 'lib/rubino/config/configuration.rb', line 308

def tool_enabled?(name)
  dig("tools", name.to_s) == true
end

#tool_output_capture_max_bytes ⇒ Object

Hard RAM ceiling for the shell capture seam (#539). Defaults via the defaults hash; coerced to a sane positive floor so a misconfig can’t disable the cap and re-open the unbounded-producer OOM.



315
316
317
318
 
# File 'lib/rubino/config/configuration.rb', line 315

def tool_output_capture_max_bytes
  value = dig("tool_output", "capture_max_bytes").to_i
  value.positive? ? value : 2_000_000
end

#tool_output_compression_code ⇒ Object 



327
328
329
 
# File 'lib/rubino/config/configuration.rb', line 327

def tool_output_compression_code
  dig("tool_output_compression", "code") || {}
end

#tool_output_compression_code_languages ⇒ Object

Source languages the code skeletoner is enabled for (e.g. [“ruby”]). A whole-file read whose language isn’t in this list passes through verbatim. Ruby uses the built-in Prism parser; later languages need their own parser registered before being added here.



335
336
337
 
# File 'lib/rubino/config/configuration.rb', line 335

def tool_output_compression_code_languages
  tool_output_compression_code["languages"] || []
end

#tool_output_compression_diff ⇒ Object

DIFF compression config. Like ‘code`, it has NO own `enabled` sub-flag: it is active whenever the master `tool_output_compression.enabled` is on. The DiffCompressor’s saving guard (min_lines + min_saving) is the real gate — a small/tight diff passes through byte-identical on its own.



343
344
345
 
# File 'lib/rubino/config/configuration.rb', line 343

def tool_output_compression_diff
  dig("tool_output_compression", "diff") || {}
end

#tool_output_compression_enabled? ⇒ Boolean

Deterministic, reversible compression of tool-read results (whole-file Ruby reads → skeleton). OFF by default: when false the read tool is byte-for-byte unchanged. See Compression::Compressor.

Returns:

  • (Boolean) 


323
324
325
 
# File 'lib/rubino/config/configuration.rb', line 323

def tool_output_compression_enabled?
  dig("tool_output_compression", "enabled") == true
end

#tool_output_compression_json ⇒ Object

JSON compression config. Like ‘code`/`diff`, it has NO own `enabled` sub-flag: it is active whenever the master `tool_output_compression.enabled` is on. The JsonCompressor’s saving + size guards are the real gate — small JSON the model wants verbatim passes through byte-identical on its own.



358
359
360
 
# File 'lib/rubino/config/configuration.rb', line 358

def tool_output_compression_json
  dig("tool_output_compression", "json") || {}
end

#tool_output_compression_logs ⇒ Object

LOG/command-output compression config. Independently gated from ‘code` via its own `enabled` flag, so we can flip the high-ROI log channel on without touching the code-skeleton channel.



350
351
352
 
# File 'lib/rubino/config/configuration.rb', line 350

def tool_output_compression_logs
  dig("tool_output_compression", "logs") || {}
end

#tool_output_compression_logs_enabled? ⇒ Boolean

Returns:

  • (Boolean) 


362
363
364
 
# File 'lib/rubino/config/configuration.rb', line 362

def tool_output_compression_logs_enabled?
  tool_output_compression_logs["enabled"] == true
end

#ui_verbose? ⇒ Boolean

– UI section –

Returns:

  • (Boolean) 


31
32
33
 
# File 'lib/rubino/config/configuration.rb', line 31

def ui_verbose?
  dig("ui", "verbose") == true
end