openclacky 1.1.0 → 1.1.2

data/lib/clacky/openai_stream_aggregator.rb

@@ -0,0 +1,130 @@
+# frozen_string_literal: true
+
+require "json"
+
+module Clacky
+  # Reassembles an OpenAI-compatible chat-completion event stream into the
+  # non-streaming response shape that MessageFormat::OpenAI.parse_response
+  # consumes, while invoking on_chunk(input_tokens:, output_tokens:) every
+  # time the upstream emits a new usage frame.
+  #
+  # Streaming frames look like:
+  #
+  #   {"id":"...","choices":[{"index":0,"delta":{"role":"assistant"},"finish_reason":null}]}
+  #   {"id":"...","choices":[{"index":0,"delta":{"content":"Hi"},"finish_reason":null}]}
+  #   {"id":"...","choices":[{"index":0,"delta":{"tool_calls":[{"index":0,"id":"call_x","function":{"name":"shell","arguments":"{\"cmd"}}]}}]}
+  #   {"id":"...","choices":[{"index":0,"delta":{"tool_calls":[{"index":0,"function":{"arguments":"\":\"ls\"}"}}]}}]}
+  #   {"id":"...","choices":[{"index":0,"delta":{},"finish_reason":"tool_calls"}]}
+  #   {"id":"...","choices":[],"usage":{"prompt_tokens":12,"completion_tokens":3,"prompt_tokens_details":{"cached_tokens":2}}}
+  #   data: [DONE]
+  class OpenAIStreamAggregator
+    def initialize(on_chunk: nil)
+      @on_chunk = on_chunk
+      @content = +""
+      @reasoning_content = +""
+      @role = "assistant"
+      @finish_reason = nil
+      @tool_calls = {}
+      @usage = nil
+      @last_input_tokens = 0
+      @last_output_tokens = 0
+    end
+
+    def handle(data_str)
+      return if data_str == "[DONE]"
+      data = parse_or_nil(data_str)
+      return unless data
+
+      if (choice = (data["choices"] || []).first)
+        delta = choice["delta"] || {}
+        @role = delta["role"] if delta["role"]
+        @content << delta["content"] if delta["content"].is_a?(String)
+        @reasoning_content << delta["reasoning_content"] if delta["reasoning_content"].is_a?(String)
+        if (tcs = delta["tool_calls"])
+          tcs.each { |tc| merge_tool_call(tc) }
+        end
+        @finish_reason = choice["finish_reason"] if choice["finish_reason"]
+        emit_estimate_progress
+      end
+
+      if (u = data["usage"])
+        @usage = u
+        emit_usage_progress(u)
+      end
+    end
+
+    # Render the canonical non-streaming response shape.
+    def to_h
+      tool_calls = @tool_calls.keys.sort.map do |idx|
+        tc = @tool_calls[idx]
+        {
+          "id"       => tc[:id],
+          "type"     => tc[:type] || "function",
+          "function" => {
+            "name"      => tc[:name],
+            "arguments" => tc[:arguments].to_s
+          }
+        }
+      end
+
+      message = {
+        "role"    => @role,
+        "content" => @content.empty? ? nil : @content
+      }
+      message["tool_calls"] = tool_calls unless tool_calls.empty?
+      message["reasoning_content"] = @reasoning_content unless @reasoning_content.empty?
+
+      {
+        "choices" => [{ "index" => 0, "message" => message, "finish_reason" => @finish_reason }],
+        "usage"   => @usage || {}
+      }
+    end
+
+    private def merge_tool_call(tc)
+      idx = tc["index"] || @tool_calls.size
+      slot = (@tool_calls[idx] ||= { id: nil, type: nil, name: nil, arguments: +"" })
+      slot[:id] ||= tc["id"] if tc["id"]
+      slot[:type] ||= tc["type"] if tc["type"]
+      if (fn = tc["function"])
+        slot[:name] ||= fn["name"] if fn["name"]
+        slot[:arguments] << fn["arguments"].to_s if fn["arguments"]
+      end
+    end
+
+    private def parse_or_nil(s)
+      JSON.parse(s)
+    rescue JSON::ParserError
+      nil
+    end
+
+    private def emit_estimate_progress
+      return unless @on_chunk
+      output = approximate_output_tokens
+      return if output == @last_output_tokens
+      @last_output_tokens = output
+      @on_chunk.call(input_tokens: @last_input_tokens, output_tokens: output)
+    rescue => e
+      Clacky::Logger.warn("[OpenAIStreamAggregator] on_chunk: #{e.class}: #{e.message}")
+    end
+
+    # Rough char/4 estimate; replaced by the real count when the upstream
+    # finally emits a usage frame (with stream_options.include_usage=true).
+    private def approximate_output_tokens
+      total_chars = @content.bytesize + @reasoning_content.bytesize +
+        @tool_calls.values.sum { |tc| tc[:arguments].to_s.bytesize }
+      (total_chars / 4.0).ceil
+    end
+
+    private def emit_usage_progress(u)
+      return unless @on_chunk
+      total_prompt = u["prompt_tokens"].to_i
+      output       = u["completion_tokens"].to_i
+      return if total_prompt == @last_input_tokens && output == @last_output_tokens
+      @last_input_tokens = total_prompt
+      @last_output_tokens = output
+      @on_chunk.call(input_tokens: total_prompt, output_tokens: output)
+    rescue => e
+      Clacky::Logger.warn("[OpenAIStreamAggregator] on_chunk: #{e.class}: #{e.message}")
+    end
+  end
+end

data/lib/clacky/server/channel/adapters/weixin/adapter.rb

@@ -8,6 +8,163 @@ module Clacky
   module Channel
     module Adapters
       module Weixin
+        # Per-user send queue with buffering, throttling, and retry for Weixin iLink.
+        #
+        # Design:
+        #   - Each chat_id has a pending buffer of text fragments.
+        #   - A background flusher thread periodically checks all buffers.
+        #   - Flush triggers: char threshold reached, time interval elapsed, or explicit flush.
+        #   - Actual send calls are spaced by MIN_SEND_INTERVAL to avoid rate-limiting.
+        #   - ret:-2 (rate-limited) triggers exponential backoff retry.
+        class SendQueue
+          FLUSH_CHAR_THRESHOLD = 400
+          FLUSH_INTERVAL       = 0.8
+          MIN_SEND_INTERVAL    = 1.0
+          RETRY_BACKOFFS       = [1.0, 2.0, 4.0]
+
+          Entry = Struct.new(:text, :context_token, :enqueued_at, keyword_init: true)
+
+          def initialize(api_client, logger: Clacky::Logger)
+            @api_client   = api_client
+            @logger       = logger
+            @buffers      = {}
+            @buffer_mutex = Mutex.new
+            @last_sent_at = {}
+            @last_mutex   = Mutex.new
+            @running      = true
+            @flusher      = Thread.new { flush_loop }
+          end
+
+          # Enqueue text for a chat_id. Non-blocking.
+          def enqueue(chat_id, text, context_token)
+            @buffer_mutex.synchronize do
+              @buffers[chat_id] ||= []
+              @buffers[chat_id] << Entry.new(text: text, context_token: context_token, enqueued_at: Time.now)
+            end
+          end
+
+          # Force-flush all pending text for a chat_id. Non-blocking.
+          def flush(chat_id)
+            entries = @buffer_mutex.synchronize { @buffers.delete(chat_id) || [] }
+            send_entries(chat_id, entries) unless entries.empty?
+          end
+
+          # Stop the flusher thread. Waits up to 30s for pending messages to drain.
+          def stop
+            @running = false
+            @flusher.join(30)
+            # Force-flush any remaining entries regardless of threshold.
+            drain_all_buffers
+          end
+
+          private def flush_loop
+            while @running
+              sleep 0.2
+              begin
+                drain_buffers
+              rescue => e
+                @logger.error("[WeixinSendQueue] drain_buffers error: #{e.message}")
+              end
+            end
+          end
+
+          private def drain_buffers
+            now = Time.now
+            ready = {}
+
+            @buffer_mutex.synchronize do
+              @buffers.each do |chat_id, entries|
+                next if entries.empty?
+                total_chars = entries.sum { |e| e.text.chars.length }
+                elapsed = now - entries.first.enqueued_at
+                if total_chars >= FLUSH_CHAR_THRESHOLD || elapsed >= FLUSH_INTERVAL
+                  ready[chat_id] = entries
+                end
+              end
+              ready.each_key { |chat_id| @buffers.delete(chat_id) }
+            end
+
+            ready.each do |chat_id, entries|
+              send_entries(chat_id, entries)
+            end
+          end
+
+          # Unconditionally drain every buffer. Used on stop to guarantee delivery.
+          private def drain_all_buffers
+            ready = @buffer_mutex.synchronize do
+              snapshot = @buffers.reject { |_, entries| entries.empty? }
+              @buffers.clear
+              snapshot
+            end
+
+            ready.each do |chat_id, entries|
+              begin
+                send_entries(chat_id, entries)
+              rescue => e
+                @logger.error("[WeixinSendQueue] final drain error for #{chat_id}: #{e.message}")
+              end
+            end
+          end
+
+          private def send_entries(chat_id, entries)
+            return if entries.empty?
+
+            combined = entries.map(&:text).join("\n")
+            ctoken   = entries.last.context_token
+
+            # Split into ≤2000 char chunks
+            chunks = split_message(combined)
+            chunks.each do |chunk|
+              throttle
+              send_with_retry(chat_id, chunk, ctoken)
+            end
+          end
+
+          private def throttle
+            @last_mutex.synchronize do
+              last = @last_sent_at[:global] || Time.at(0)
+              wait = MIN_SEND_INTERVAL - (Time.now - last)
+              sleep(wait) if wait > 0
+              @last_sent_at[:global] = Time.now
+            end
+          end
+
+          private def send_with_retry(chat_id, text, context_token)
+            RETRY_BACKOFFS.each_with_index do |delay, idx|
+              begin
+                @api_client.send_text(to_user_id: chat_id, text: text, context_token: context_token)
+                return
+              rescue ApiClient::ApiError => e
+                if e.code == -2 && idx < RETRY_BACKOFFS.length - 1
+                  @logger.warn("[WeixinSendQueue] ret=-2 for #{chat_id}, retry in #{delay}s (#{idx + 1}/#{RETRY_BACKOFFS.length})")
+                  sleep delay
+                  next
+                end
+                raise
+              end
+            end
+          rescue => e
+            @logger.error("[WeixinSendQueue] send_text failed for #{chat_id}: #{e.message}")
+          end
+
+          # Split text into ≤2000 Unicode character chunks.
+          private def split_message(text, limit: 2000)
+            return [text] if text.chars.length <= limit
+            chunks = []
+            while text.chars.length > limit
+              window = text.chars.first(limit).join
+              cut = window.rindex("\n\n")
+              cut = window.rindex("\n")   if cut.nil?
+              cut = window.rindex(" ")    if cut.nil?
+              cut = limit                 if cut.nil? || cut.zero?
+              chunks << text.chars.first(cut).join.rstrip
+              text = text.chars.drop(cut).join.lstrip
+            end
+            chunks << text unless text.empty?
+            chunks
+          end
+        end
+
         # Weixin (WeChat iLink) adapter.
         #
         # Protocol: HTTP long-poll via ilinkai.weixin.qq.com
@@ -76,6 +233,7 @@ module Clacky
             @context_tokens = {}
             @ctx_mutex      = Mutex.new
             @api_client     = ApiClient.new(base_url: @base_url, token: @token)
+            @send_queue     = SendQueue.new(@api_client)
             # Typing keepalive: user_id → { ticket:, thread:, cached_at: }
             @typing_tickets  = {}
             @typing_mutex    = Mutex.new
@@ -129,10 +287,12 @@ module Clacky
 
           def stop
             @running = false
+            @send_queue.stop
           end
 
           # Send a plain text reply to a user.
           # The context_token from the inbound message is required by the Weixin protocol.
+          # Text is enqueued and sent in batches by the background flusher to avoid rate-limiting.
           def send_text(chat_id, text, reply_to: nil)
             ctoken = lookup_context_token(chat_id)
             unless ctoken
@@ -141,14 +301,15 @@ module Clacky
             end
 
             plain = markdown_to_plain(text)
-            split_message(plain).each do |chunk|
-              @api_client.send_text(to_user_id: chat_id, text: chunk, context_token: ctoken)
-            end
+            return { message_id: nil } if plain.empty?
 
+            @send_queue.enqueue(chat_id, plain, ctoken)
             { message_id: nil }
-          rescue => e
-            Clacky::Logger.error("[WeixinAdapter] send_text failed for #{chat_id} (context_token=#{lookup_context_token(chat_id).to_s.slice(0, 20)}...): #{e.message}")
-            { message_id: nil }
+          end
+
+          # Force-flush pending text for a chat_id. Called before sending files or on task completion.
+          def flush_pending(chat_id)
+            @send_queue.flush(chat_id)
           end
 
           # Send a file to a user.
@@ -161,6 +322,8 @@ module Clacky
               return { message_id: nil }
             end
 
+            @send_queue.flush(chat_id)
+
             @api_client.send_file(
               to_user_id:    chat_id,
               file_path:     file_path,

data/lib/clacky/server/channel/channel_ui_controller.rb

@@ -62,6 +62,7 @@ module Clacky
         # raw markdown links would just be noise in the chat.
         text = content.to_s.gsub(/!?\[[^\]]*\]\(file:\/\/[^)]+\)/, "").strip
         send_text(text) unless text.empty?
+        flush_adapter_pending
         files.each do |f|
           Clacky::Logger.info("[ChannelUI] sending file path=#{f[:path].inspect} name=#{f[:name].inspect}")
           send_file(f[:path], f[:name])
@@ -120,6 +121,7 @@ module Clacky
         end
         parts << "#{duration.round(1)}s" if duration
         send_text(parts.join(" · "))
+        flush_adapter_pending
       end
 
       def append_output(content)
@@ -218,6 +220,10 @@ module Clacky
         send_text(@buffer.join("\n"))
         @buffer.clear
       end
+
+      def flush_adapter_pending
+        @adapter.flush_pending(@chat_id) if @adapter.respond_to?(:flush_pending)
+      end
     end
   end
 end

data/lib/clacky/server/http_server.rb

@@ -3156,6 +3156,7 @@ module Clacky
       # Export a session bundle as a .zip download containing:
       #   - session.json          (always)
       #   - chunk-*.md            (0..N archived conversation chunks)
+      #   - logs/clacky-YYYY-MM-DD.log  (today's logger file, if present)
       # Useful for debugging — user clicks "download" in the WebUI status bar
       # and we can ask them to attach the zip to a bug report.
       def api_export_session(session_id, res)
@@ -3177,6 +3178,12 @@ module Clacky
             zos.put_next_entry(File.basename(chunk_path))
             zos.write(File.binread(chunk_path))
           end
+
+          log_path = Clacky::Logger.current_log_file
+          if log_path && File.exist?(log_path)
+            zos.put_next_entry("logs/#{File.basename(log_path)}")
+            zos.write(File.binread(log_path))
+          end
         end
         buffer.rewind
         data = buffer.read
@@ -3365,9 +3372,8 @@ module Clacky
         return unless agent
 
         # Auto-name the session from the first user message (before agent starts running).
-        # Check messages.empty? only — agent.name may already hold a default placeholder
-        # like "Session 1" assigned at creation time, so it's not a reliable signal.
-        if agent.history.empty?
+        # Skip if the name looks like it was set by the user (not a system-generated "Session N").
+        if agent.history.empty? && agent.name.match?(/\ASession \d+\z/)
           auto_name = content.gsub(/\s+/, " ").strip[0, 30]
           auto_name += "…" if content.strip.length > 30
           agent.rename(auto_name)

data/lib/clacky/server/web_ui_controller.rb

@@ -225,15 +225,19 @@ module Clacky
 
       def show_progress(message = nil, prefix_newline: true, progress_type: "thinking", phase: "active", metadata: {})
         if phase == "active"
-          @progress_start_time = Time.now
-          # Store complete progress state for replay when user switches back to this session
+          # Only set start time when transitioning into a fresh progress phase.
+          # Streaming LLM calls fire show_progress every chunk for token updates;
+          # resetting the timer each time would make the elapsed counter jitter
+          # back to 0 in the UI and force the frontend to rebuild its interval.
+          if @live_progress_state.nil? || @live_progress_state[:progress_type] != progress_type
+            @progress_start_time = Time.now
+            @live_stdout_buffer = []
+          end
           @live_progress_state = {
             message: message,
             progress_type: progress_type,
             metadata: metadata
           }
-          # Reset stdout buffer for each new command so re-subscribe only replays current run
-          @live_stdout_buffer = []
         elsif phase == "done"
           @live_tool_call = nil   # command finished — nothing left to replay
           # Keep @live_stdout_buffer intact — it will be reset on the next show_progress call.

data/lib/clacky/tools/terminal.rb

@@ -494,6 +494,12 @@ module Clacky
           else
             cleanup_session(session)
           end
+          if xcode_tools_missing?(cleaned)
+            cleaned = "Xcode Command Line Tools are not installed.\n" \
+                      "Run: bash ~/.clacky/scripts/install_system_deps.sh\n" \
+                      "Then retry the original command."
+            exit_code = 1
+          end
           {
             output: cleaned,
             exit_code: exit_code,
@@ -521,6 +527,11 @@ module Clacky
         end
       end
 
+      private def xcode_tools_missing?(output)
+        return false if output.nil? || output.empty?
+        output.include?("xcode-select") && output.include?("No developer tools were found")
+      end
+
       private def session_healthy?(session)
         return false unless session
         return false if %w[exited killed].include?(session.status.to_s)

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

@@ -57,6 +57,7 @@ module Clacky
 
           # Session bar info
           @sessionbar_info = {
+            session_id: nil,   # Full session id; rendered as first 8 chars (parity with WebUI)
             working_dir: nil,
             mode: nil,
             model: nil,
@@ -138,6 +139,7 @@ module Clacky
         end
 
         # Update session bar info
+        # @param session_id [String] Full session id (rendered as first 8 chars)
         # @param working_dir [String] Working directory
         # @param mode [String] Permission mode
         # @param model [String] AI model name
@@ -145,7 +147,8 @@ module Clacky
         # @param cost [Float] Total cost
         # @param cost_source [Symbol, nil] :api / :price / :default — :default renders as N/A
         # @param status [String] Workspace status ('idle' or 'working')
-        def update_sessionbar(working_dir: nil, mode: nil, model: nil, tasks: nil, cost: nil, cost_source: nil, status: nil)
+        def update_sessionbar(session_id: nil, working_dir: nil, mode: nil, model: nil, tasks: nil, cost: nil, cost_source: nil, status: nil)
+          @sessionbar_info[:session_id] = session_id if session_id
           @sessionbar_info[:working_dir] = working_dir if working_dir
           @sessionbar_info[:mode] = mode if mode
           @sessionbar_info[:model] = model if model
@@ -1136,6 +1139,12 @@ module Clacky
             parts << "#{status_indicator} #{@pastel.public_send(status_color, @sessionbar_info[:status])}"
           end
 
+          # Session id — first 8 chars (parity with WebUI #sib-id)
+          if @sessionbar_info[:session_id]
+            sid_short = @sessionbar_info[:session_id].to_s[0, 8]
+            parts << theme.format_text(sid_short, :statusbar_secondary) unless sid_short.empty?
+          end
+
           # Working directory (shortened if too long)
           if @sessionbar_info[:working_dir]
             dir_display = shorten_path(@sessionbar_info[:working_dir])

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

@@ -14,9 +14,13 @@ module Clacky
 
         def initialize
           @todos = []
+          @pending_todos = []
+          @completed_count = 0
+          @total_count = 0
           @pastel = Pastel.new
           @width = TTY::Screen.width
           @height = 0  # Dynamic height based on todos
+          @hidden = false
         end
 
         # Update todos list
@@ -27,8 +31,24 @@ module Clacky
           @completed_count = @todos.count { |t| t[:status] == "completed" }
           @total_count = @todos.size
 
-          # Calculate height: 0 if no pending, otherwise 1 line per task (up to MAX_DISPLAY_TASKS)
-          if @pending_todos.empty?
+          recalc_height
+        end
+
+        # Hide the area without discarding todos data; show again to restore.
+        def hide
+          return if @hidden
+          @hidden = true
+          @height = 0
+        end
+
+        def show
+          return unless @hidden
+          @hidden = false
+          recalc_height
+        end
+
+        private def recalc_height
+          if @hidden || @pending_todos.empty?
             @height = 0
           else
             @height = [@pending_todos.size, MAX_DISPLAY_TASKS].min

data/lib/clacky/ui2/layout_manager.rb

@@ -126,6 +126,10 @@ module Clacky
 
           old_lines = entry.lines.dup
           new_lines = wrap_content_to_lines(content)
+          if old_lines == new_lines
+            screen.flush
+            return
+          end
           @buffer.replace(id, new_lines)
 
           unless @fullscreen_mode
@@ -288,24 +292,28 @@ module Clacky
           end
         end
 
-        # Clear the rows the entry currently occupies
-        (start_row...@output_row).each do |row|
-          screen.move_cursor(row, 0)
-          screen.clear_line
-        end
-
-        # Paint the new content
+        # Clear only rows whose content actually changed, then repaint
+        # those. Lines that are byte-identical to the previous frame stay
+        # untouched — avoiding the clear-then-redraw flicker that an
+        # always-on ticker produces 2-10x per second on slower terminals.
         cur = start_row
-        new_lines.each do |line|
-          screen.move_cursor(cur, 0)
-          print line
+        new_lines.each_with_index do |line, i|
+          if i >= old_n || old_lines[i] != line
+            screen.move_cursor(cur, 0)
+            screen.clear_line
+            print line
+          end
           cur += 1
         end
+        # If content shrank, blank out the rows the old frame occupied
+        # below the new tail.
+        if new_n < old_n
+          (cur...(start_row + old_n)).each do |row|
+            screen.move_cursor(row, 0)
+            screen.clear_line
+          end
+        end
         @output_row = start_row + new_n
-
-        # If content shrank, extra rows below may still hold the old content
-        # if they were outside the cleared range — but since we cleared the
-        # full old span above, nothing extra is needed here.
       end
 
       # Clear the last N rows of the output area (used by remove_entry on tail).
@@ -502,6 +510,54 @@ module Clacky
         end
       end
 
+      # Hide todo area while preserving its data; pair with show_todos.
+      def hide_todos
+        return unless @todo_area
+
+        @render_mutex.synchronize do
+          old_height  = @todo_area.height
+          old_gap_row = @gap_row
+
+          @todo_area.hide
+          new_height = @todo_area.height
+
+          if old_height != new_height
+            calculate_layout
+            ([old_gap_row, 0].max...screen.height).each do |row|
+              screen.move_cursor(row, 0)
+              screen.clear_line
+            end
+          end
+
+          render_fixed_areas
+          screen.flush
+        end
+      end
+
+      # Show todo area again after a previous hide_todos.
+      def show_todos
+        return unless @todo_area
+
+        @render_mutex.synchronize do
+          old_height  = @todo_area.height
+          old_gap_row = @gap_row
+
+          @todo_area.show
+          new_height = @todo_area.height
+
+          if old_height != new_height
+            calculate_layout
+            ([old_gap_row, 0].max...screen.height).each do |row|
+              screen.move_cursor(row, 0)
+              screen.clear_line
+            end
+          end
+
+          render_fixed_areas
+          screen.flush
+        end
+      end
+
 
 
       # -----------------------------------------------------------------------