openclacky 1.2.18 → 1.3.0

data/lib/clacky/tools/trash_manager.rb

@@ -470,6 +470,7 @@ module Clacky
         return false unless File.exist?(json_path)
 
         sm.send(:_hard_delete_session_with_chunks, json_path)
+        _delete_snapshots(session[:session_id])
         true
       end
 
@@ -492,7 +493,9 @@ module Clacky
             next unless Time.parse(trash_time.to_s) < cutoff
           end
 
+          sid = session[:session_id]
           sm.send(:_hard_delete_session_with_chunks, filepath)
+          _delete_snapshots(sid)
           deleted += 1
         end
 
@@ -501,6 +504,17 @@ module Clacky
 
       # ── private class helper ──────────────────────────────────────────
 
+      # Remove a session's Time Machine snapshots. Snapshots are pure
+      # undo-history caches keyed by full session_id, so they can be dropped
+      # whenever the session is permanently deleted.
+      def self._delete_snapshots(session_id)
+        return if session_id.to_s.empty?
+
+        dir = File.join(Dir.home, ".clacky", "snapshots", session_id.to_s)
+        FileUtils.rm_rf(dir) if Dir.exist?(dir)
+      end
+      private_class_method :_delete_snapshots
+
       def self._trash_sessions(sm)
         trash_dir = Clacky::TrashDirectory.sessions_trash_dir
         Dir.glob(File.join(trash_dir, "*.json")).filter_map do |filepath|

data/lib/clacky/ui2/components/command_suggestions.rb

@@ -15,6 +15,7 @@ module Clacky
         SYSTEM_COMMANDS = [
           { command: "/clear", description: "Clear chat history and restart session" },
           { command: "/config", description: "Open configuration (models, API keys, settings)" },
+          { command: "/model", description: "Quickly switch the current model" },
           { command: "/undo", description: "Undo the last task and restore previous state" },
           { command: "/help", description: "Show help information" },
           { command: "/exit", description: "Exit the chat session" },

data/lib/clacky/ui2/components/modal_component.rb

@@ -32,7 +32,11 @@ module Clacky
         #                              Should return { success: true } or { success: false, error: "message" }
         # @param on_close [Proc, nil] Optional callback to execute when modal closes (e.g., to re-render screen)
         # @return [Hash, nil] Hash of field values or selected value, or nil if cancelled
-        def show(title:, fields: nil, choices: nil, validator: nil, on_close: nil)
+        # @param nav_keys [Boolean] when true, → on an expandable choice returns
+        #   { nav: :expand, value: } and ←/Esc returns { nav: :back }, letting the
+        #   caller drive multi-page (drawer) navigation within one modal flow.
+        # @param instructions [String, nil] override the bottom hint line.
+        def show(title:, fields: nil, choices: nil, validator: nil, on_close: nil, initial_index: nil, nav_keys: false, instructions: nil)
           @title = title
           @mode = choices ? :menu : :form
           @fields = fields || []
@@ -40,10 +44,18 @@ module Clacky
           @values = {}
           @error_message = nil
           @selected_index = 0
+          @nav_keys = nav_keys
+          @instructions = instructions
           
-          # For menu mode, find first non-disabled choice
+          # For menu mode, default to first non-disabled choice, unless the
+          # caller pinned an initial cursor position (e.g. Time Machine wants
+          # the cursor to land on the currently-active task).
           if @mode == :menu
-            @selected_index = @choices.index { |c| !c[:disabled] } || 0
+            if initial_index && @choices[initial_index] && !@choices[initial_index][:disabled]
+              @selected_index = initial_index
+            else
+              @selected_index = @choices.index { |c| !c[:disabled] } || 0
+            end
           end
 
           # Adjust height based on mode
@@ -108,13 +120,23 @@ module Clacky
             when "\e"  # Escape sequence
               seq = STDIN.read_nonblock(2) rescue ''
               if seq.empty?
-                # Just Esc key - cancel
+                # Just Esc key. With nav_keys, Esc means "back" (the caller
+                # decides whether that's go-to-parent or cancel); otherwise cancel.
                 print "\e[?25l"
-                return nil
+                return @nav_keys ? { nav: :back } : nil
               elsif seq == '[A'  # Up arrow
                 move_menu_selection(-1)
               elsif seq == '[B'  # Down arrow
                 move_menu_selection(1)
+              elsif seq == '[C' && @nav_keys  # Right arrow - expand
+                selected = @choices[@selected_index]
+                if selected && !selected[:disabled] && selected[:expandable]
+                  print "\e[?25l"
+                  return { nav: :expand, value: selected[:value] }
+                end
+              elsif seq == '[D' && @nav_keys  # Left arrow - back
+                print "\e[?25l"
+                return { nav: :back }
               end
             when "\u0003"  # Ctrl+C
               print "\e[?25l"
@@ -376,7 +398,12 @@ module Clacky
             text = @pastel.dim(choice_text)
           elsif is_selected
             marker = @pastel.bright_cyan("→ ")
-            text = @pastel.bright_white(choice_text)
+            text = choice[:dim] ? @pastel.dim(choice_text) : @pastel.bright_white(choice_text)
+          elsif choice[:dim]
+            # Undone / abandoned-branch task: keep it visually de-emphasized
+            # even when not under the cursor.
+            marker = "  "
+            text = @pastel.dim(choice_text)
           else
             marker = "  "
             text = @pastel.white(choice_text)
@@ -394,7 +421,7 @@ module Clacky
 
         # Draw menu instructions
         private def draw_menu_instructions(row, col)
-          instructions = "↑↓/jk: Navigate • Enter: Select • Esc/q: Cancel"
+          instructions = @instructions || "↑↓/jk: Navigate • Enter: Select • Esc/q: Cancel"
           padding = (@width - instructions.length - 2) / 2
           remaining = @width - padding - instructions.length - 2
           

data/lib/clacky/ui2/ui_controller.rb

@@ -149,7 +149,8 @@ module Clacky
         update_sessionbar
       end
 
-      # Stop the UI controller
+      # Stop the UI controller. Keeps the screen by default so any final
+      # output (e.g. the "clacky -a <id>" resume hint) survives in scrollback.
       def stop(clear_screen: false)
         @running = false
         @layout.cleanup_screen(clear_screen: clear_screen)
@@ -959,6 +960,8 @@ module Clacky
           separator,
           "",
           theme.format_text("Commands:", :info),
+          "  #{theme.format_text("/model", :success)}       - Quickly switch the current model",
+          "  #{theme.format_text("/config", :success)}      - Configure models, API keys, settings",
           "  #{theme.format_text("/clear", :success)}       - Clear output and restart session",
           "  #{theme.format_text("/exit", :success)}        - Exit application",
           "",
@@ -1519,46 +1522,174 @@ module Clacky
         end
       end
 
+      # Quick model switcher — lists configured model cards and returns the
+      # picked card's stable id. Unlike show_config_modal this never mutates
+      # config; it's a pure picker. All side effects live in the CLI layer.
+      # @return [Hash, nil] { model_id: <id> } or nil if cancelled / no models
+      # Two-level drawer picker for /model.
+      #
+      # Level 1 (card list): Enter selects a card and uses its default model
+      # (clearing any sub-model overlay); → opens that card's sub-model drawer
+      # (only for cards whose provider exposes >= 2 sub-models, marked "›").
+      #
+      # Level 2 (sub-model list): Enter pins the chosen sub-model (or Default);
+      # ← / Esc returns to the card list.
+      #
+      # @param current_config [AgentConfig]
+      # @param submodels_for [Proc] called with a card hash, returns its provider
+      #   sub-model names (or [] if none / single).
+      # @return [Hash, nil] { model_id:, model_name: } where model_name is the
+      #   chosen sub-model (nil = the card's own default), or nil if cancelled.
+      public def show_model_switch_modal(current_config, submodels_for)
+        return nil if current_config.models.empty?
+
+        on_close = -> { @layout.rerender_all }
+
+        loop do
+          card = show_model_card_level(current_config, submodels_for, on_close)
+          return nil if card.nil?
+
+          # Plain card pick (Enter): use the card default, clear overlay.
+          return { model_id: card[:model_id], model_name: nil } unless card[:expand]
+
+          # → opened the drawer: let the user pick a sub-model for this card.
+          model = current_config.models.find { |m| m["id"] == card[:model_id] }
+          drawer = {
+            model_id: card[:model_id],
+            card_model: card[:card_model],
+            submodels: submodels_for.call(model) || [],
+            current_overlay: current_config.session_model_overlay_name
+          }
+          sub = show_model_submodel_level(drawer, on_close)
+          next if sub == :back  # ← / Esc: back to the card list
+
+          return { model_id: card[:model_id], model_name: sub }
+        end
+      end
+
+      # Level 1: card list. Returns { model_id:, expand: bool } on Enter/→,
+      # or nil if cancelled.
+      private def show_model_card_level(current_config, submodels_for, on_close)
+        current_overlay = current_config.session_model_overlay_name
+
+        choices = current_config.models.each_with_index.map do |model, idx|
+          is_current = (idx == current_config.current_model_index)
+          card_model = model["model"] || "unnamed"
+          type_badge = case model["type"]
+                       when "default" then " [default]"
+                       when "lite" then " [lite]"
+                       else ""
+                       end
+          expandable = (submodels_for.call(model) || []).length >= 2
+
+          marker = is_current ? "● " : "  "
+          arrow = expandable ? "  ›" : ""
+          {
+            name: "#{marker}#{card_model}#{type_badge}#{arrow}",
+            value: { model_id: model["id"], card_model: card_model },
+            expandable: expandable
+          }
+        end
+
+        result = Components::ModalComponent.new.show(
+          title: "Switch Model",
+          choices: choices,
+          nav_keys: true,
+          instructions: "↑↓ move • Enter select • → submodels • Esc cancel",
+          on_close: on_close
+        )
+
+        return nil if result.nil? || (result.is_a?(Hash) && result[:nav] == :back)
+
+        if result.is_a?(Hash) && result[:nav] == :expand
+          { model_id: result[:value][:model_id], card_model: result[:value][:card_model], expand: true }
+        else
+          { model_id: result[:model_id], card_model: result[:card_model], expand: false }
+        end
+      end
+
+      # Level 2: sub-model list for one card. Returns the chosen sub-model name,
+      # nil (the card default), or :back to return to the card list.
+      private def show_model_submodel_level(card, on_close)
+        submodels = card[:submodels]
+        current = card[:current_overlay]
+        card_model = card[:card_model]
+
+        choices = [{
+          name: "#{current.nil? ? '● ' : '  '}Default (#{card_model})",
+          value: { model_name: nil }
+        }]
+        submodels.each do |name|
+          choices << {
+            name: "#{name == current ? '● ' : '  '}#{name}",
+            value: { model_name: name }
+          }
+        end
+
+        result = Components::ModalComponent.new.show(
+          title: card_model,
+          choices: choices,
+          nav_keys: true,
+          instructions: "↑↓ move • Enter select • ←/Esc back",
+          on_close: on_close
+        )
+
+        return :back if result.nil? || (result.is_a?(Hash) && result[:nav] == :back)
+
+        result[:model_name]
+      end
+
       # Show time machine menu for task undo/redo
       # @param history [Array<Hash>] Task history with format: [{task_id, summary, status, has_branches}]
       # @return [Integer, nil] Selected task ID or nil if cancelled
       public def show_time_machine_menu(history)
         modal = Components::ModalComponent.new
-        
+
+        active_index = nil
+
         # Build menu choices from history
-        choices = history.map do |task|
-          # Build visual indicator
-          indicator = if task[:status] == :current
-            "→ "  # Current task
-          elsif task[:status] == :future
-            "↯ "  # Future task (after undo)
+        choices = history.each_with_index.map do |task, idx|
+          # Status marker. The cursor itself draws a "→", so use distinct
+          # glyphs here to avoid visual collision:
+          #   ● current   · on-path history   ✗ undone/abandoned branch
+          marker = case task[:status]
+          when :current
+            active_index = idx
+            "● "
+          when :undone
+            "✗ "
           else
-            "  "  # Past task
+            "· "
           end
-          
-          # Add branch indicator
-          indicator += "⎇ " if task[:has_branches]
-          
+
+          # Branch indicator
+          marker += "⎇ " if task[:has_branches]
+
           # Truncate summary to fit on screen
           max_summary_length = 60
           summary = task[:summary]
           if summary.length > max_summary_length
             summary = summary[0...max_summary_length] + "..."
           end
-          
+
+          label = "#{marker}Task #{task[:task_id]}: #{summary}"
+          label += "  (undone)" if task[:status] == :undone
+
           {
-            name: "#{indicator}Task #{task[:task_id]}: #{summary}",
-            value: task[:task_id]
+            name: label,
+            value: task[:task_id],
+            dim: task[:status] == :undone
           }
         end
-        
-        # Show modal
+
+        # Show modal, landing the cursor on the currently-active task.
         result = modal.show(
           title: "Time Machine - Select Task to Navigate",
           choices: choices,
+          initial_index: active_index,
           on_close: -> { @layout.rerender_all }
         )
-        
+
         result # Return selected task_id or nil
       end
       

data/lib/clacky/utils/file_processor.rb

@@ -59,6 +59,15 @@ module Clacky
       ".jpeg" => "image/jpeg",
       ".gif"  => "image/gif",
       ".webp" => "image/webp",
+      ".mp4"  => "video/mp4",
+      ".webm" => "video/webm",
+      ".mov"  => "video/quicktime",
+      ".wav"  => "audio/wav",
+      ".mp3"  => "audio/mpeg",
+      ".ogg"  => "audio/ogg",
+      ".aac"  => "audio/aac",
+      ".flac" => "audio/flac",
+      ".m4a"  => "audio/mp4",
       ".pdf"  => "application/pdf"
     }.freeze
 
@@ -528,6 +537,9 @@ module Clacky
 
     # Image extensions that can be inlined as data URLs in markdown content.
     LOCAL_IMAGE_EXTENSIONS = %w[.png .jpg .jpeg .gif .webp].freeze
+    LOCAL_VIDEO_EXTENSIONS = %w[.mp4 .webm .mov].freeze
+    LOCAL_AUDIO_EXTENSIONS = %w[.wav .mp3 .ogg .aac .flac .m4a].freeze
+    LOCAL_MEDIA_EXTENSIONS = (LOCAL_IMAGE_EXTENSIONS + LOCAL_VIDEO_EXTENSIONS + LOCAL_AUDIO_EXTENSIONS).freeze
 
     # Replace local image paths in markdown content with base64 data URLs.
     #
@@ -582,22 +594,81 @@ module Clacky
     def self.rewrite_local_image_urls(content)
       return content if content.nil? || content.empty?
 
-      content.gsub(/!\[([^\]]*)\]\(((?:file:\/\/)?\/[^)]+)\)/) do |match|
+      # Rewrite markdown image syntax ![alt](file:///path) → proxy URL
+      content = content.gsub(/!\[([^\]]*)\]\(((?:file:\/\/)?\/[^)]+)\)/) do |_match|
         alt  = Regexp.last_match(1)
         href = Regexp.last_match(2)
 
-        # Extract the filesystem path from the href
         path = href.sub(%r{\Afile://}, "")
         path = CGI.unescape(path)
 
         ext = File.extname(path).downcase
-        if LOCAL_IMAGE_EXTENSIONS.include?(ext) && File.exist?(path)
+        if LOCAL_MEDIA_EXTENSIONS.include?(ext) && File.exist?(path)
           encoded = CGI.escape(href)
           "![#{alt}](/api/local-image?path=#{encoded})"
         else
-          match # return original match unchanged
+          _match
         end
       end
+
+      # Rewrite <video src="file:///path/vid.mp4" ...> → proxy URL
+      content = content.gsub(/<video\b([^>]*)\bsrc="((?:file:\/\/)?\/[^"]+)"([^>]*)>/) do |_match|
+        pre  = Regexp.last_match(1) || ""
+        href = Regexp.last_match(2)
+        post = Regexp.last_match(3) || ""
+
+        path = href.sub(%r{\Afile://}, "")
+        path = CGI.unescape(path)
+
+        ext = File.extname(path).downcase
+        if LOCAL_VIDEO_EXTENSIONS.include?(ext) && File.exist?(path)
+          encoded = CGI.escape(href)
+          "<video#{pre} src=\"/api/local-image?path=#{encoded}\"#{post}>"
+        else
+          _match
+        end
+      end
+
+      # Rewrite <audio src="file:///path/audio.wav" ...> → proxy URL
+      content = content.gsub(/<audio\b([^>]*)\bsrc="((?:file:\/\/)?\/[^"]+)"([^>]*)>/) do |_match|
+        pre  = Regexp.last_match(1) || ""
+        href = Regexp.last_match(2)
+        post = Regexp.last_match(3) || ""
+
+        path = href.sub(%r{\Afile://}, "")
+        path = CGI.unescape(path)
+
+        ext = File.extname(path).downcase
+        if LOCAL_AUDIO_EXTENSIONS.include?(ext) && File.exist?(path)
+          encoded = CGI.escape(href)
+          "<audio#{pre} src=\"/api/local-image?path=#{encoded}\"#{post}>"
+        else
+          _match
+        end
+      end
+
+      # Rewrite video/audio markdown links [text](file:///path) → proxy URL
+      content = content.gsub(/(?<!!)\[([^\]]*)\]\(((?:file:\/\/)?\/[^)]+)\)/) do |_match|
+        text = Regexp.last_match(1)
+        href = Regexp.last_match(2)
+
+        path = href.sub(%r{\Afile://}, "")
+        path = CGI.unescape(path)
+
+        ext = File.extname(path).downcase
+        if LOCAL_VIDEO_EXTENSIONS.include?(ext) || LOCAL_AUDIO_EXTENSIONS.include?(ext)
+          if File.exist?(path)
+            encoded = CGI.escape(href)
+            "[#{text}](/api/local-image?path=#{encoded})"
+          else
+            _match
+          end
+        else
+          _match
+        end
+      end
+
+      content
     end
   end
   end

data/lib/clacky/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module Clacky
-  VERSION = "1.2.18"
+  VERSION = "1.3.0"
 end