Class: Rubino::UI::Null

Inherits:
Base
  • Object
show all
Defined in:
lib/rubino/ui/null.rb

Overview

Null UI adapter that discards all output. Used in testing and background job execution where no terminal output is needed.

Instance Attribute Summary collapse

Instance Method Summary collapse

Methods inherited from Base

#blocking_human_input?, #hint_row, #panel_line, #turn_interrupted

Constructor Details

#initialize ⇒ Null

Returns a new instance of Null.



11
12
13
 
# File 'lib/rubino/ui/null.rb', line 11

def initialize
  @messages = []
end

Instance Attribute Details

#messages ⇒ Object (readonly)

Returns the value of attribute messages.



9
10
11
 
# File 'lib/rubino/ui/null.rb', line 9

def messages
  @messages
end

Instance Method Details

#ask(_prompt) ⇒ Object 



95
96
97
 
# File 'lib/rubino/ui/null.rb', line 95

def ask(_prompt)
  nil
end

#assistant_text(text) ⇒ Object 



47
48
49
 
# File 'lib/rubino/ui/null.rb', line 47

def assistant_text(text)
  @messages << { level: :assistant_text, message: text }
end

#blank_line ⇒ Object 



157
158
159
 
# File 'lib/rubino/ui/null.rb', line 157

def blank_line
  @messages << { level: :blank_line, message: "" }
end

#body(text) ⇒ Object 



43
44
45
 
# File 'lib/rubino/ui/null.rb', line 43

def body(text)
  @messages << { level: :body, message: text }
end

#box_close(*pieces, color: nil) ⇒ Object 



39
40
41
 
# File 'lib/rubino/ui/null.rb', line 39

def box_close(*pieces, color: nil)
  @messages << { level: :box_close, pieces: pieces, color: color }
end

#box_open(*pieces, at: nil, color: nil) ⇒ Object 



35
36
37
 
# File 'lib/rubino/ui/null.rb', line 35

def box_open(*pieces, at: nil, color: nil)
  @messages << { level: :box_open, pieces: pieces, at: at, color: color }
end

#branch_confirmation(new_id:, parent_id:, title:, included_probe:) ⇒ Object 



59
60
61
62
63
64
65
 
# File 'lib/rubino/ui/null.rb', line 59

def branch_confirmation(new_id:, parent_id:, title:, included_probe:)
  @messages << {
    level: :branch_confirmation,
    message: { new_id: new_id, parent_id: parent_id, title: title,
               included_probe: included_probe }
  }
end

#compression_finished(metadata, at: nil) ⇒ Object 



137
138
139
 
# File 'lib/rubino/ui/null.rb', line 137

def compression_finished(metadata, at: nil)
  @messages << { level: :compression_finished, message: metadata, at: at }
end

#compression_started(at: nil) ⇒ Object 



133
134
135
 
# File 'lib/rubino/ui/null.rb', line 133

def compression_started(at: nil)
  @messages << { level: :compression_started, message: "", at: at }
end

#confirm(_question, scope: nil, **_context) ⇒ Object

‘scope:` is part of the shared UI contract (ToolExecutor always passes it); the Null adapter auto-approves and ignores it.



107
108
109
 
# File 'lib/rubino/ui/null.rb', line 107

def confirm(_question, scope: nil, **_context)
  true
end

#confirm_destructive(_question) ⇒ Object

Destructive confirm (#218): no human to ask, so fail closed (decline) — never destroy on the non-interactive Null adapter.



113
114
115
 
# File 'lib/rubino/ui/null.rb', line 113

def confirm_destructive(_question)
  false
end

#error(message) ⇒ Object 



27
28
29
 
# File 'lib/rubino/ui/null.rb', line 27

def error(message)
  @messages << { level: :error, message: message }
end

#info(message) ⇒ Object 



15
16
17
 
# File 'lib/rubino/ui/null.rb', line 15

def info(message)
  @messages << { level: :info, message: message }
end

#input_injected(text) ⇒ Object 



185
186
187
 
# File 'lib/rubino/ui/null.rb', line 185

def input_injected(text)
  @messages << { level: :input_injected, message: text }
end

#job_enqueued(type) ⇒ Object 



141
142
143
 
# File 'lib/rubino/ui/null.rb', line 141

def job_enqueued(type)
  @messages << { level: :job_enqueued, message: type }
end

#job_finished(type) ⇒ Object 



149
150
151
 
# File 'lib/rubino/ui/null.rb', line 149

def job_finished(type)
  @messages << { level: :job_finished, message: type }
end

#job_started(type) ⇒ Object 



145
146
147
 
# File 'lib/rubino/ui/null.rb', line 145

def job_started(type)
  @messages << { level: :job_started, message: type }
end

#mode_changed(name, previous: nil) ⇒ Object 



161
162
163
 
# File 'lib/rubino/ui/null.rb', line 161

def mode_changed(name, previous: nil)
  @messages << { level: :mode_changed, message: name, previous: previous }
end

#note(text) ⇒ Object 



51
52
53
 
# File 'lib/rubino/ui/null.rb', line 51

def note(text)
  @messages << { level: :note, message: text }
end

#probe_aside(answer) ⇒ Object 



55
56
57
 
# File 'lib/rubino/ui/null.rb', line 55

def probe_aside(answer)
  @messages << { level: :probe_aside, message: answer.to_s }
end

#queued(text) ⇒ Object 



181
182
183
 
# File 'lib/rubino/ui/null.rb', line 181

def queued(text)
  @messages << { level: :queued, message: text }
end

#reasoning_changed(mode, previous: nil) ⇒ Object 



169
170
171
 
# File 'lib/rubino/ui/null.rb', line 169

def reasoning_changed(mode, previous: nil)
  @messages << { level: :reasoning_changed, message: mode, previous: previous }
end

#reasoning_status(mode) ⇒ Object 



165
166
167
 
# File 'lib/rubino/ui/null.rb', line 165

def reasoning_status(mode)
  @messages << { level: :reasoning_status, message: mode }
end

#replay_user_input(text, at: nil) ⇒ Object 



79
80
81
 
# File 'lib/rubino/ui/null.rb', line 79

def replay_user_input(text, at: nil)
  @messages << { level: :replay_user_input, message: text, at: at }
end

#reset! ⇒ Object

Resets captured messages (useful between test cases)



190
191
192
 
# File 'lib/rubino/ui/null.rb', line 190

def reset!
  @messages = []
end

#select(_prompt, _choices) ⇒ Object

No interactive selection off a real terminal; callers fall back to a non-interactive path (e.g. the static /sessions table + shortcut).



101
102
103
 
# File 'lib/rubino/ui/null.rb', line 101

def select(_prompt, _choices)
  nil
end

#separator ⇒ Object 



153
154
155
 
# File 'lib/rubino/ui/null.rb', line 153

def separator
  @messages << { level: :separator, message: "" }
end

#status(message) ⇒ Object 



31
32
33
 
# File 'lib/rubino/ui/null.rb', line 31

def status(message)
  @messages << { level: :status, message: message }
end

#stream(chunk) ⇒ Object 



67
68
69
70
71
72
73
 
# File 'lib/rubino/ui/null.rb', line 67

def stream(chunk)
  # Every adapter yields the common chunk contract:
  #   { type: :content | :thinking, text: String, message_id: Integer }
  text = chunk[:text].to_s
  type = chunk[:type] || :content
  @messages << { level: :stream, message: text, stream_type: type }
end

#stream_end ⇒ Object 



75
76
77
 
# File 'lib/rubino/ui/null.rb', line 75

def stream_end
  @messages << { level: :stream_end, message: "" }
end

#success(message) ⇒ Object 



19
20
21
 
# File 'lib/rubino/ui/null.rb', line 19

def success(message)
  @messages << { level: :success, message: message }
end

#table(headers:, rows:) ⇒ Object 



91
92
93
 
# File 'lib/rubino/ui/null.rb', line 91

def table(headers:, rows:)
  @messages << { level: :table, message: { headers: headers, rows: rows } }
end

#think_changed(effort, previous: nil) ⇒ Object 



177
178
179
 
# File 'lib/rubino/ui/null.rb', line 177

def think_changed(effort, previous: nil)
  @messages << { level: :think_changed, message: effort, previous: previous }
end

#think_status(effort) ⇒ Object 



173
174
175
 
# File 'lib/rubino/ui/null.rb', line 173

def think_status(effort)
  @messages << { level: :think_status, message: effort }
end

#thinking_finished ⇒ Object 



87
88
89
 
# File 'lib/rubino/ui/null.rb', line 87

def thinking_finished
  @messages << { level: :thinking_finished, message: "" }
end

#thinking_started ⇒ Object 



83
84
85
 
# File 'lib/rubino/ui/null.rb', line 83

def thinking_started
  @messages << { level: :thinking_started, message: "" }
end

#tool_body(text, kind: :plain) ⇒ Object 



125
126
127
 
# File 'lib/rubino/ui/null.rb', line 125

def tool_body(text, kind: :plain)
  @messages << { level: :tool_body, message: text, kind: kind }
end

#tool_chunk(name, chunk) ⇒ Object 



129
130
131
 
# File 'lib/rubino/ui/null.rb', line 129

def tool_chunk(name, chunk)
  @messages << { level: :tool_chunk, name: name, chunk: chunk }
end

#tool_finished(name, result: nil) ⇒ Object 



121
122
123
 
# File 'lib/rubino/ui/null.rb', line 121

def tool_finished(name, result: nil)
  @messages << { level: :tool_finished, message: name }
end

#tool_started(name, arguments: nil, at: nil) ⇒ Object 



117
118
119
 
# File 'lib/rubino/ui/null.rb', line 117

def tool_started(name, arguments: nil, at: nil)
  @messages << { level: :tool_started, message: name, arguments: arguments, at: at }
end

#warning(message) ⇒ Object 



23
24
25
 
# File 'lib/rubino/ui/null.rb', line 23

def warning(message)
  @messages << { level: :warning, message: message }
end