openclacky 1.5.13 → 1.5.15

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: ca259b2f17df9695e21c4d4c4f18ee83affec0fc41d67db829d903e1c3bb008d
-  data.tar.gz: b0bfd31378c6b452a7aef246d3d316242a91fa6366f543c45edcff8c3f44ac6c
+  metadata.gz: 878e99c7061a59dee8c50f4ec416986c33c7d93538595e90719042827a9b774e
+  data.tar.gz: 51a940cdc2e2f25b95a6ce96d84cd7c45988154b324ca2c9962bcddf4f213fa4
 SHA512:
-  metadata.gz: cfcb5b28264aeb2acb6b121b89c395e4e9241b3a3135c2e9fb7d565365ed263c701f939448a2c01cb229359cca11402b36b081d4edff6231ce8e46e72d253498
-  data.tar.gz: 95cca310ebd8e0a23b1f1e5aed241b6e5fbc19aa206fdb16301dfd3b90f07e33424a44686c10b2d6cf4d3344c75eab2c033d7b3e4e7ef6c9a40b7879dd07a88b
+  metadata.gz: 82af0b7e1e966e3e8eafc888006a05e75f637b6d6508721432bc484394f9699cb2a82ad0f0abee73cd88214bcad6e865acf8e1840e357059a470aee5e59f00c5
+  data.tar.gz: f996cf6c38e1070608dd49955e68c1154301152b8fc51d0e3e392055dcd51bebc21c234e0bf20fddbdb0a2a9ba48dcc527afcfd1e92e43fc2fc82a1ddbbcfa33

data/CHANGELOG.md

@@ -4,6 +4,102 @@ All notable changes to this project will be documented in this file.
 
 The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.0.0/),
 
+## [1.5.15] - 2026-09-17
+
+### Added
+- Quote text selected in a message and send it as a reference badge
+- Queue messages while the agent is working, with pending-message controls in the CLI and Web UI (#561)
+- Steer a running turn with a queued message
+- Discover custom-endpoint models from the add-model dialog (#560 - @kylezhang)
+- Show vendor badges for each provider in the add-model dropdown
+- Label every model with its provider in the model picker
+- Open unviewable files in the system app and reveal them in the workspace tree
+- Follow the browsed directory in the directory picker sidebar
+- Show the extension and skill lists as segmented tabs in Extension Studio
+- Add disclosure carets to the clickable status-bar fields
+- Resolve redirected Windows shell folders in the WSL directory picker
+- Show web search results as UI results in the chat
+
+### Improved
+- Swap the extension and channel management order in the sidebar
+- Rename the Tasks sidebar entry to Scheduled Tasks
+- Improve mobile folder navigation in the directory picker (#549)
+- Improve the mobile layout of settings tabs and model controls (#548)
+- Add a global focus ring for keyboard navigation (#544)
+- Align the input behavior toggle with the send buttons
+- Deepen the directory-picker breadcrumb field
+- Keep the segmented control highlight dark on the dim and bluedark themes
+- Retire the dsk-deepseek-v4-flash model ids
+
+### Fixed
+- Keep the mobile composer above the soft keyboard (#557)
+- Install newly published brand skills when an agent starts
+- Show the marketplace takedown state instead of an unusable unpublish button
+- Show complete brand distribution for brand owners (#556)
+- Focus brand owners on brand publishing in Extension Studio (#555)
+- Hide the creator center from branded non-owners (#553)
+- Forward brand marketplace sorting to the backend (#552)
+- Complete the public session creation lifecycle (#551)
+- Make the @ mention menu selectable on the new-session page (#558)
+- Show a searched old session in the sidebar without a reload
+- Stop session updated_at from rolling back on save
+- Avoid a duplicated empty state in the sidebar search
+- Align reasoning and image fields with the Responses API schema
+- Use theme tokens for the badge colors
+- Give the calendar popup its own class namespace
+- Add the default user prompt for attachments
+
+## [1.5.14] - 2026-09-10
+
+### Added
+- Add a click-driven live preview panel for workspace files and localhost dev servers
+- Open local files in the preview panel via file:// URLs and bare absolute paths
+- Add GPT-5.6 Sol/Terra/Luna and GPT-6 Astra models with Global CRIS pricing
+- Add the deepseek-flash model
+- Add an editable Chinese metadata form and field-level frontmatter update API for skills
+- Add a /think reasoning-effort switcher to the TUI
+- Render CSV/TSV files as read-only tables in the workspace
+- Add Parallel Free as the primary built-in web-search provider
+- Select text in a message and quote it into the composer (#526 - @kylezhang)
+- Syntax-highlight code in the file viewer
+- Send large STT audio as base64 JSON (#525 - @tomash)
+- Add a Files panel open-with menu, tree toggle, split preview, and in-menu download
+- Detect Windows apps for open-with in WSL
+- Skip registering the browser tool when it is disabled
+- Auto-snapshot the page after browser actions
+- Truncate long working directories in the session info bar
+- Highlight width-drag handles on hover
+
+### Improved
+- Switch the default model to Gemini 3.8 Flash
+- Use single-pane navigation on mobile (C-5779) (#539)
+- Polish the chat navigator layout and hover interactions (#527)
+- Improve message navigation in long conversations (#523)
+- Refine the billing tooltip UX (C-5778) (#537)
+- Let the git panel fill the aside height and free up diff width (#531)
+
+### Fixed
+- Restore the aside width after closing file previews (#545)
+- Replace undefined danger tokens with the error color variable (#542 - @sundevilyang)
+- Add hover and disabled feedback to danger and secondary buttons (#541, #540 - @sundevilyang)
+- Correct DeepSeek v4-pro and flash pricing
+- Collapse extension actions into a menu on narrow screens (C-5781) (#538)
+- Don't submit argumented commands on Enter
+- Scroll overflow menus and pin config action buttons
+- Sniff binary content before text preview (C-5690) (#535)
+- Require a slash prefix for channel help commands (C-5641) (#533)
+- Normalize the homepage URL scheme on read (C-5666) (#534)
+- Decode non-ASCII paths in git panel output (C-5777) (#530)
+- Refresh the file tree on working-dir switch and task completion
+- Harden extension developer guidance and manifest validation (#524)
+- Fix zip file encoding errors
+- Resolve file://~/ tilde paths from chat links
+- Align the open-button icon
+
+### More
+- Move the preview tab to the end of the left-nav order
+- Extract provider id constants to replace magic strings
+
 ## [1.5.13] - 2026-09-03
 
 ### Added

data/lib/clacky/agent/chunk_index.rb

@@ -0,0 +1,83 @@
+# frozen_string_literal: true
+
+module Clacky
+  class Agent
+    # Byte ranges only: no message bodies, tool outputs or persistent sidecars.
+    module ChunkIndex
+      private def chunk_section_header(line, directory)
+        if (match = line.match(/\A## Assistant \[Compressed Summary — original conversation at: (.+)\]/))
+          { role: "assistant", nested_chunk: File.join(directory, match[1]) }
+        elsif (match = line.match(/\A## (User|Assistant)(?: \[Task ([1-9]\d*)\])?\z/))
+          { role: match[1].downcase, task_id: match[2]&.to_i }
+        elsif line.start_with?("### Tool Result:")
+          { role: "tool" }
+        end
+      end
+
+      private def chunk_file_version(path)
+        stat = File.stat(path)
+        [stat.size, stat.mtime.to_f, stat.ctime.to_f].join(":")
+      rescue Errno::ENOENT
+        "missing"
+      end
+
+      private def chunk_navigation_index(path)
+        version = chunk_file_version(path)
+        @chunk_index_mutex ||= Mutex.new
+        @chunk_index_mutex.synchronize do
+          @chunk_indexes ||= {}
+          cached = @chunk_indexes[path]
+          return cached if cached && cached[:version] == version
+
+          index = version == "missing" ? { rounds: [], nested: [], section_count: 0 } : scan_chunk_index(path)
+          raise ArgumentError, "History changed while indexing" unless chunk_file_version(path) == version
+
+          @chunk_indexes[path] = index.merge(version: version)
+        end
+      end
+
+      private def scan_chunk_index(path)
+        rounds = []
+        nested = []
+        section_count = 0
+        user_start = nil
+        archived_at = nil
+        front_matter = false
+        directory = File.dirname(path)
+        position = 0
+        File.open(path, "rb") do |file|
+          while (line = file.gets)
+            start = position
+            position += line.bytesize
+            text = line.force_encoding(Encoding::UTF_8).scrub.chomp
+            if start.zero? && text == "---"
+              front_matter = true
+            elsif front_matter
+              front_matter = false if text == "---"
+              archived_at = (Time.parse(text.split(":", 2).last.strip) rescue nil) if text.start_with?("archived_at:")
+            end
+            header = chunk_section_header(text, directory)
+            if header
+              section_count += 1
+              nested << header[:nested_chunk] if header[:nested_chunk]
+              user_start = header[:role] == "user" ? start : nil
+            elsif user_start && !text.strip.empty?
+              # Match replay's empty/metadata-only user handling without
+              # retaining the rest of the user message or any assistant text.
+              visible, events = extract_ext_events_from_text(text)
+              visible, files = extract_display_files_from_text(visible)
+              next if visible.empty? && events.empty? && files.empty?
+
+              rounds.last[:length] = user_start - rounds.last[:start] if rounds.any?
+              rounds << { start: user_start }
+              user_start = nil
+            end
+          end
+          rounds.last[:length] = position - rounds.last[:start] if rounds.any?
+        end
+        { rounds: rounds, nested: nested, section_count: section_count,
+          base_time: (archived_at || File.mtime(path)).to_f }
+      end
+    end
+  end
+end

data/lib/clacky/agent/history_navigation.rb

@@ -0,0 +1,239 @@
+# frozen_string_literal: true
+
+module Clacky
+  class Agent
+    # Read-only navigation: locations at startup, bounded previews on demand.
+    module HistoryNavigation
+      NAVIGATION_PREVIEW_LENGTH = 400
+      NAVIGATION_PREVIEW_BATCH_LIMIT = 30
+
+      def history_navigation
+        sources = navigation_sources
+        manifest = sources.map do |source|
+          entry = { key: source[:key], version: source[:version], count: navigation_source_count(source),
+                    volatile: !!source[:rounds] || source[:continuation].to_a.any? }
+          entry[:identities] = source[:rounds].map { |round| round[:user_msg].values_at(:created_at, :task_id) } if source[:rounds]
+          entry
+        end
+        { sources: manifest, total: manifest.sum { |source| source[:count] } }
+      end
+
+      def history_navigation_preview(id:)
+        history_navigation_previews(ids: [id]).fetch(0)
+      end
+
+      def history_navigation_previews(ids:)
+        ids = Array(ids)
+        if ids.length > NAVIGATION_PREVIEW_BATCH_LIMIT
+          raise ArgumentError, "Too many history locations"
+        end
+
+        sources = navigation_sources
+        ids.map do |id|
+          source_index, offset = navigation_position(sources, id)
+          unless offset && offset < navigation_source_count(sources[source_index])
+            raise ArgumentError, "History location is no longer available"
+          end
+          navigation_entry(navigation_source_rounds(sources, source_index, offset: offset, limit: 1).fetch(0))
+        end
+      end
+
+      def replay_history_window(ui, limit: 30, around: nil, before_id: nil, after_id: nil)
+        sources = navigation_sources
+        anchor = around || before_id || after_id
+        source_index, offset = anchor ? navigation_position(sources, anchor) : [sources.length - 1, nil]
+        count = navigation_source_count(sources[source_index])
+        offset ||= count
+        raise ArgumentError, "History location is no longer available" if anchor && offset >= count
+
+        # Around starts at the requested round; before/after are exclusive.
+        forward = !!(around || after_id)
+        offset += 1 if after_id
+        page = []
+        index = source_index
+        while index.between?(0, sources.length - 1) && page.length < limit
+          count = navigation_source_count(sources[index])
+          if forward
+            first = index == source_index ? offset : 0
+            page.concat(navigation_source_rounds(sources, index, offset: first, limit: limit - page.length))
+            index += 1
+          else
+            last = index == source_index ? offset : count
+            first = [last - (limit - page.length), 0].max
+            page = navigation_source_rounds(sources, index, offset: first, limit: last - first) + page
+            index -= 1
+          end
+        end
+
+        if page.empty? && !anchor
+          @history.to_a.each do |message|
+            next if message[:role].to_s == "system" || message[:system_injected]
+            _replay_single_message(message, ui)
+          end
+        else
+          replay_rounds(ui, page)
+        end
+        first = page.first&.dig(:navigation_id)
+        last = page.last&.dig(:navigation_id)
+        first_pos = first && navigation_position(sources, first)
+        last_pos = last && navigation_position(sources, last)
+        has_before = first_pos && (first_pos[1].positive? || first_pos[0].positive?)
+        has_after = last_pos && (last_pos[1] < navigation_source_count(sources[last_pos[0]]) - 1 ||
+          ((last_pos[0] + 1)...sources.length).any? { |i| navigation_source_count(sources[i]).positive? })
+        {
+          has_more: !!has_before, has_after: !!has_after,
+          before_cursor: first, after_cursor: last,
+          round_ids: page.map { |round| round[:navigation_id] }
+        }
+      end
+
+      private def real_history_user?(msg)
+        return false unless msg[:role].to_s == "user" && !msg[:system_injected]
+
+        content = msg[:content]
+        if content.is_a?(String)
+          !content.start_with?("[SYSTEM]")
+        elsif content.is_a?(Array)
+          content.any? { |block| block.is_a?(Hash) && %w[text image image_url].include?((block[:type] || block["type"]).to_s) }
+        else
+          false
+        end
+      end
+
+      private def navigation_sources
+        messages = @history.to_a
+        rounds = []
+        leading = []
+        chunks = []
+        messages.each do |msg|
+          if real_history_user?(msg)
+            rounds << { user_msg: msg, events: [], editable: true }
+          elsif msg[:compressed_summary]
+            paths = if msg[:chunk_path].to_s.empty?
+              session_manager.chunks_for_current(@session_id, @created_at).map { |chunk| chunk[:path] }
+            else
+              sibling_chunks_of(msg[:chunk_path])
+            end
+            chunks.concat(paths)
+          elsif rounds.empty?
+            leading << msg unless msg[:role].to_s == "system" || msg[:system_injected]
+          else
+            rounds.last[:events] << msg
+          end
+        end
+        sources = []
+        visited = Set.new
+        top_level = chunks.map { |path| File.basename(path) }.to_set
+        append_source = lambda do |path|
+          path = File.join(Clacky::SessionManager::SESSIONS_DIR, File.basename(path)) unless File.exist?(path)
+          path = File.expand_path(path)
+          next unless visited.add?(path)
+
+          index = chunk_navigation_index(path)
+          # Legacy nested references precede this source's own rounds. Sibling
+          # chunks already enumerated above must not be counted twice.
+          index[:nested].reverse_each do |nested|
+            append_source.call(nested) unless top_level.include?(File.basename(nested))
+          end
+          sources << { key: File.basename(path), path: path, version: index[:version], index: index }
+        end
+        chunks.uniq.each { |path| append_source.call(path) }
+        @chunk_index_mutex&.synchronize { @chunk_indexes&.delete_if { |path, _| !visited.include?(path) } }
+        last_archive = sources.reverse_each.find { |source| navigation_source_count(source).positive? }
+        last_archive[:continuation] = leading if last_archive
+        version = rounds.map { |round| round[:user_msg].values_at(:created_at, :task_id) }.hash.to_s
+        sources << { key: "live", rounds: rounds, version: version }
+        sources
+      end
+
+      private def navigation_source_count(source)
+        source[:rounds] ? source[:rounds].length : source[:index][:rounds].length
+      end
+
+      private def navigation_id(source, offset)
+        identity = source[:rounds] && offset && source[:rounds][offset]&.dig(:user_msg)&.values_at(:created_at, :task_id)
+        JSON.generate([source[:key], offset, source[:version], identity])
+      end
+
+      private def navigation_position(sources, id)
+        key, offset, version, identity = JSON.parse(id)
+        index = sources.index { |source| source[:key] == key }
+        if index && key == "live" && version != sources[index][:version] && identity.is_a?(Array) && identity.any?
+          matches = sources[index][:rounds].each_index.select do |i|
+            sources[index][:rounds][i][:user_msg].values_at(:created_at, :task_id) == identity
+          end
+          if matches.one?
+            offset = matches.first
+            version = sources[index][:version]
+          end
+        end
+        unless index && sources[index][:version] == version && (offset.nil? || (offset.is_a?(Integer) && offset >= 0))
+          raise ArgumentError, "History location is no longer available"
+        end
+        [index, offset]
+      rescue JSON::ParserError, TypeError
+        raise ArgumentError, "Invalid history location"
+      end
+
+      private def navigation_source_rounds(sources, index, offset: 0, limit: nil)
+        source = sources.fetch(index)
+        count = navigation_source_count(source)
+        length = [limit || count, count - offset].min
+        return [] unless length.positive?
+
+        siblings = sources.filter_map { |entry| entry[:key] if entry[:path] && entry != source }.to_set
+        rounds = if source[:rounds]
+          source[:rounds].slice(offset, length)
+        else
+          ranges = source[:index][:rounds]
+          first = ranges[offset]
+          last = ranges[offset + length - 1]
+          range = { start: first[:start], length: last[:start] + last[:length] - first[:start] }
+          result = parse_chunk_md_to_rounds(source[:path], excluded_paths: siblings, byte_range: range,
+            index: source[:index], round_offset: offset)
+          unless chunk_file_version(source[:path]) == source[:version] && result.length == length
+            raise ArgumentError, "History changed while reading"
+          end
+          result
+        end
+        if rounds.any? && offset + length == count && source[:continuation]
+          rounds.last[:events].concat(source[:continuation])
+        end
+        rounds.each { |round| round[:events].reject! { |event| event[:compressed_summary] } }
+        rounds.each_with_index do |round, position|
+          round[:navigation_id] = navigation_id(source, offset + position)
+        end
+        rounds
+      end
+
+      private def navigation_entry(round)
+        msg = round[:user_msg]
+        user = navigation_preview(msg[:display_text] || extract_text_from_content(msg[:content]))
+        if user.empty?
+          names = Array(msg[:display_files]).map { |file| file[:name] || file["name"] }
+          Array(msg[:content]).each do |block|
+            next unless block.is_a?(Hash) && %w[image image_url].include?((block[:type] || block["type"]).to_s)
+            names << (block[:image_name] || block["image_name"] || "image")
+          end
+          user = navigation_preview(names.compact.join(", "))
+        end
+        # A final reply is the last main-agent response, with no pending tool
+        # work. Earlier narration, reasoning and nested subagent transcripts
+        # must never be substituted for a missing final response.
+        last = round[:events].reverse.find do |event|
+          !event[:system_injected] && !event[:compressed_summary] &&
+            %w[assistant tool].include?(event[:role].to_s)
+        end
+        final = last && last[:role].to_s == "assistant" && !last[:interim] && Array(last[:tool_calls]).empty?
+        answer = final ? navigation_preview(extract_text_from_content(last[:content])) : ""
+        { id: round[:navigation_id], created_at: msg[:created_at], archived: round[:editable] == false,
+          user: user, assistant: answer }
+      end
+
+      private def navigation_preview(text)
+        text.to_s.gsub(/<think>.*?(?:<\/think>|\z)/m, "")
+          .strip[0, NAVIGATION_PREVIEW_LENGTH]
+      end
+    end
+  end
+end