Class: Rubino::CLI::Chat::ImageInbox

Inherits:
Object
  • Object
show all
Defined in:
lib/rubino/cli/chat/image_inbox.rb

Overview

The REPL's image-attachment inbox (attach an image from the terminal), extracted from ChatCommand (#17).

Attachments live in #pending_image_paths between the prompt read and the turn; run_turn consumes + clears them via #take! so each image is sent once into the native vision slot (image_paths → Lifecycle#execute → adapter with:).

Class Method Summary collapse

Instance Method Summary collapse

Class Method Details

.resolve_oneshot(query, flag_values) ⇒ Object

Builds the [text, image_paths] pair for a one-shot turn. Pulls @image / dropped-path tokens out of the prompt (so they hit the vision slot, not the literal text) and prepends any paths given via --image. Flag paths are expanded the same way as in-line tokens; a flag path that isn't a readable image is reported and skipped rather than silently dropped.

Every candidate then passes the SAME secure-by-default attachment gate as the server/run path (Attachments::Classify + Policy, via ImageInput#attachment_error) — a policy rejection is a clean one-line error BEFORE any network call, not five provider retries (#98).



24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
 
# File 'lib/rubino/cli/chat/image_inbox.rb', line 24

def self.resolve_oneshot(query, flag_values)
  flag_paths = Array(flag_values).map { |p| Interaction::ImageInput.expand(p) }
  flag_paths.each do |p|
    next if LLM::ContentBuilder.image_file?(p) && File.file?(p)

    warn "rubino: ignoring --image #{p} (not a readable image file)"
  end
  valid_flags = flag_paths.select { |p| LLM::ContentBuilder.image_file?(p) && File.file?(p) }
  valid_flags.each do |p|
    reason = Interaction::ImageInput.attachment_error(p)
    raise Rubino::Error, "--image #{p}: #{reason}" if reason
  end

  result = Interaction::ImageInput.parse(query, existing: valid_flags)
  if (rejection = result.rejected.first)
    raise Rubino::Error, "#{rejection[:path]}: #{rejection[:reason]}"
  end

  [result.text, result.image_paths]
end

Instance Method Details

#extract_images!(input, ui) ⇒ Object

Parses the line for image references (@image, dropped/quoted/escaped path), moves any into @pending_image_paths and returns the cleaned text. Non-image references are left in the text (current behaviour). Shows an in-prompt indicator for whatever is now attached. A candidate the attachment policy rejects (oversize / spoofed extension / unsafe) is dropped with a one-line warning instead of being shipped (#98).



85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
 
# File 'lib/rubino/cli/chat/image_inbox.rb', line 85

def extract_images!(input, ui)
  result = Interaction::ImageInput.parse(input, existing: pending_image_paths)
  result.rejected.each do |rejection|
    ui.warning("not attached — #{File.basename(rejection[:path])}: #{rejection[:reason]}")
  end
  newly = result.image_paths - pending_image_paths
  @pending_image_paths = result.image_paths
  # A line with text AND an @image sends BOTH on THIS turn (the cleaned
  # text is non-empty, so the main loop submits now); an image-only line
  # stages for the next message. The indicator must match that
  # disposition — saying "sent with your next message" on a text+image
  # line is wrong (#225).
  unless newly.empty?
    attached_now = !result.text.strip.empty?
    show_image_indicator(ui, newly, attached_now: attached_now)
  end
  result.text
end

#handle_image_command(input, ui) ⇒ Object

Handles the REPL-local image commands. Returns true when it consumed the input (so the main loop should next), false otherwise.

/paste         — grab an image from the clipboard into image_paths
/clear-images  — drop all pending attachments

rubocop:disable Naming/PredicateMethod -- "did I consume the line", not a pure predicate



110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
 
# File 'lib/rubino/cli/chat/image_inbox.rb', line 110

def handle_image_command(input, ui)
  case input.strip.downcase
  when "/clear-images", "/clear-image"
    if pending_image_paths.empty?
      ui.info("No attached images to clear.")
    else
      ui.info("Cleared #{pending_image_paths.size} attached image(s).")
      @pending_image_paths = []
    end
    true
  when "/paste"
    paste_clipboard_image(ui)
    true
  else
    false
  end
end

#pending_image_paths ⇒ Object 



45
46
47
 
# File 'lib/rubino/cli/chat/image_inbox.rb', line 45

def pending_image_paths
  @pending_image_paths ||= []
end

#stage_flag_images(flag_values, ui) ⇒ Object

Seeds the interactive pending-images inbox from --image/-i flag paths (#160), through the SAME attachment gate every other staging surface uses (Attachments::Classify + Policy via ImageInput#attachment_error). A bad flag path warns and is skipped — interactive startup must not die on it the way one-shot raises. Staged images show the usual indicator and are covered by /clear-images, as documented.



63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
 
# File 'lib/rubino/cli/chat/image_inbox.rb', line 63

def stage_flag_images(flag_values, ui)
  Array(flag_values).each do |raw|
    path = Interaction::ImageInput.expand(raw)
    unless LLM::ContentBuilder.image_file?(path) && File.file?(path)
      ui.warning("not attached — #{raw}: not a readable image file")
      next
    end
    if (reason = Interaction::ImageInput.attachment_error(path))
      ui.warning("not attached — #{File.basename(path)}: #{reason}")
      next
    end
    pending_image_paths << path unless pending_image_paths.include?(path)
  end
  show_image_indicator(ui, pending_image_paths) unless pending_image_paths.empty?
end

#take! ⇒ Object

Consumes the turn's queued image attachments (the native vision slot) and resets so they're attached exactly once, not re-sent next turn.



51
52
53
54
55
 
# File 'lib/rubino/cli/chat/image_inbox.rb', line 51

def take!
  paths = pending_image_paths
  @pending_image_paths = []
  paths
end