openclacky 1.3.5 → 1.3.7

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 5a7474760c07220891bc62795e95ab0f5b9f83387b4881e1cc9eec4133545222
-  data.tar.gz: '099b846d3a8b44af563403c05f5bc8c855b0925122aabeb3f01b77f8f0c8d18f'
+  metadata.gz: 48e94ccf83645b5e18be8d5d33582dc128b06824ab226dd314540658b9cc7e4a
+  data.tar.gz: 1112ed443505eca99e745838377ebbf4b6f1e96a7c7f83c7bf1cff844b5ddea9
 SHA512:
-  metadata.gz: e494c9032f35cf631a91dbbff72c89004c1aa8991a6f630dc21c65a9d97b45bceb2afa9c69b2f25b0d4c0e909d317b64eff5ed7b972fd475edc2f19e81a2f779
-  data.tar.gz: 7fb32e090e6cfd780cd0b4218bbfb00a0f939ce77089cc124e35d03a8870abdbb27f09de976304526b8e905d14107fc861914ba08f80d447a72e4d24a6711c8f
+  metadata.gz: b0e4b2664bb7990ec91dd7c5598cfb561ce6f931b1f006a962b6cbf5516ee424b3a6f605fd70c3996ad4d0e0bf1a20dfd626d6466020393cc8cf18832008a68a
+  data.tar.gz: 2b74eea0a552e5d26545779da2f0a2b1f88812063398ffbf15be913e396d6efe7131d8205bff766939ef252c4ca3b8075ce8e86c855de59774226e3e03bdbfde

data/CHANGELOG.md

@@ -5,6 +5,48 @@ 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/),
 and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
 
+## [1.3.7] - 2026-07-06
+
+### Added
+- Extension ecosystem: install, manage, and publish extensions with Creator Studio
+- Brand extension and brand badge support for extension agents
+- Hook/profile extension type for intercepting and customizing agent behavior
+- Extension upload CLI for publishing extensions from the command line
+- New session page with improved layout and discoverability
+- Session auto-cleanup hint, skeleton loading, and type filter in trash panel
+- Renew button on brand warning bar for expiring subscriptions
+- i18n tooltips for header theme toggle and trash toolbar buttons
+- Refresh button in header to reload sessions
+- xhigh reasoning effort level for supported models
+- i18n file upload error messages
+
+### Improved
+- Merge Creator Center into ext-studio as a unified extension hub
+- Extension developer experience: scaffold template improvements, badge and author metadata support
+- Share modal UI polish — theme dots on hover, close button hover effect, layout refinement
+- Unify Clacky.* JS namespace and single-segment extension architecture
+- Migrate default agents to default extensions with unified panel visibility
+
+### Fixed
+- Ctrl+C now works properly in TUI auto-answer mode
+- Show-system-skills toggle persists correctly and uses theme accent color
+- Cron display handles every-N-hours with weekdays pattern correctly
+- New-session dropdown arrow button responds to both click and keyboard
+- New cron virtual entry inserts at the correct position relative to pinned sessions
+- File upload error messages use i18n consistently
+
+## [1.3.6] - 2026-06-30
+
+### Added
+- Cron task session isolation with independent pagination and stable task count
+- Backup/restore UI in settings with WebSocket reconnect refresh and WSL open-folder support
+
+### Fixed
+- Rewrite human-readable cron parser to handle comma-separated lists, hour ranges, and `*/1` normalization
+- Setup submit button hover color follows accent theme variable
+- Settings button no longer navigates away when already on settings page
+- Use Unix epoch for old thread timestamps to avoid date parsing issues
+
 ## [1.3.5] - 2026-06-29
 
 ### Added

data/lib/clacky/agent/message_compressor.rb

@@ -39,10 +39,14 @@ module Clacky
 
       REQUIRED RESPONSE FORMAT:
       First output a <topics> line listing 3-6 key topic phrases (comma-separated, concise).
+      Then output a <continues_previous> line: "true" if this conversation is a direct
+      continuation of the SAME task/topic as the PREVIOUS chunk shown below, "false" if it
+      has moved on to a different task or topic. If there is no previous chunk, output "false".
       Then output the full summary wrapped in <summary> tags.
 
       Example format:
       <topics>Rails setup, database config, deploy pipeline, Tailwind CSS</topics>
+      <continues_previous>false</continues_previous>
       <summary>
       ...full summary text...
       </summary>
@@ -54,7 +58,8 @@ module Clacky
       - Errors encountered and fixes applied
       - Current work status and pending tasks
 
-      Begin your response NOW. Remember: PURE TEXT only, starting with <topics> then <summary>.
+      Begin your response NOW. Remember: PURE TEXT only, starting with <topics> then
+      <continues_previous> then <summary>.
     PROMPT
 
     def initialize(client, model: nil)
@@ -72,18 +77,25 @@ module Clacky
     #
     # @param messages [Array<Hash>] Original conversation messages
     # @param recent_messages [Array<Hash>] Recent messages to keep uncompressed (optional)
+    # @param previous_topics [String, nil] Topics of the most recent chunk on disk,
+    #   shown to the LLM so it can decide whether the current conversation is a
+    #   continuation (drives the <continues_previous> output for chunk merging).
     # @return [Hash] Compression instruction message to insert, or nil if nothing to compress
-    def build_compression_message(messages, recent_messages: [])
+    def build_compression_message(messages, recent_messages: [], previous_topics: nil)
       # Get messages to compress (exclude system message and recent messages)
       messages_to_compress = messages.reject { |m| m[:role] == "system" || recent_messages.include?(m) }
 
       # If nothing to compress, return nil
       return nil if messages_to_compress.empty?
 
-      # Simple compression instruction - LLM can see the history already
-      { 
-        role: "user", 
-        content: COMPRESSION_PROMPT,
+      content = COMPRESSION_PROMPT
+      if previous_topics && !previous_topics.strip.empty?
+        content = "#{COMPRESSION_PROMPT}\n\nPREVIOUS CHUNK TOPICS (for <continues_previous> judgement): #{previous_topics}"
+      end
+
+      {
+        role: "user",
+        content: content,
         system_injected: true
       }
     end
@@ -142,6 +154,15 @@ module Clacky
       m ? m[1].strip : nil
     end
 
+    # Parse the <continues_previous> tag. Returns true only when the LLM
+    # explicitly says "true"; missing tag or any other value → false.
+    # This conservative default ensures we never merge unless the model is sure.
+    def parse_continues_previous(content)
+      return false if content.nil? || content.to_s.empty?
+      m = content.to_s.match(/<continues_previous>(.*?)<\/continues_previous>/m)
+      m ? m[1].strip.downcase == "true" : false
+    end
+
     def parse_compressed_result(result, chunk_path: nil, topics: nil, previous_chunks: [])
       # Return the compressed result as a single user message (role: "user").
       #
@@ -171,8 +192,11 @@ module Clacky
       if content.empty?
         []
       else
-        # Strip out the <topics> block — it's metadata for the chunk file, not for AI context
-        content_without_topics = content.gsub(/<topics>.*?<\/topics>\n*/m, "").strip
+        # Strip out the <topics> and <continues_previous> blocks — they're
+        # metadata for chunk handling, not for AI context.
+        content_without_topics = content.gsub(/<topics>.*?<\/topics>\n*/m, "")
+                                        .gsub(/<continues_previous>.*?<\/continues_previous>\n*/m, "")
+                                        .strip
 
         # Build previous chunks index section — links to older chunk files so the AI
         # can find earlier conversations without keeping all prior compressed_summary

data/lib/clacky/agent/message_compressor_helper.rb

@@ -193,8 +193,18 @@ module Clacky
         recent_messages = get_recent_messages_with_tool_pairs(all_messages, target_recent_count)
         recent_messages = [] if recent_messages.nil?
 
+        # Surface the most recent chunk's topics so the compression LLM can judge
+        # whether this conversation continues the same task (drives chunk merging).
+        previous_topics = nil
+        if @session_id && @created_at
+          latest = session_manager.chunks_for_current(@session_id, @created_at).last
+          previous_topics = latest && latest[:topics]
+        end
+
         # Build compression instruction message (to be inserted into conversation)
-        compression_message = @message_compressor.build_compression_message(all_messages, recent_messages: recent_messages)
+        compression_message = @message_compressor.build_compression_message(
+          all_messages, recent_messages: recent_messages, previous_topics: previous_topics
+        )
 
         return nil if compression_message.nil?
 
@@ -242,25 +252,52 @@ module Clacky
         # all chunk file I/O (naming, writing, discovery) — we just ask it.
         sm = session_manager
         existing_chunks = sm.chunks_for_current(@session_id, @created_at)
-        chunk_index = sm.next_chunk_index(@session_id, @created_at)
 
         # Extract topics from the LLM response to store in both the chunk MD front
         # matter and the compressed_summary message hash (for future chunk indexing).
         topics = @message_compressor.parse_topics(compressed_content)
 
-        chunk_path = save_compressed_chunk(
-          original_messages,
-          compression_context[:recent_messages],
-          chunk_index: chunk_index,
-          compression_level: compression_context[:compression_level],
-          topics: topics
-        )
+        # Decide whether to MERGE into the previous chunk or create a NEW one.
+        # The LLM judges (via <continues_previous>) whether this conversation is a
+        # direct continuation of the previous chunk's task. Merging avoids tiny
+        # fragmented chunks (e.g. a long task compressed mid-flight into 2-message
+        # chunks) that pollute the topics index and degrade recall.
+        latest_chunk = existing_chunks.last
+        continues = latest_chunk && @message_compressor.parse_continues_previous(compressed_content)
+
+        if continues
+          chunk_path = merge_into_previous_chunk(
+            latest_chunk,
+            original_messages,
+            compression_context[:recent_messages],
+            compression_level: compression_context[:compression_level],
+            topics: topics
+          )
+          # Fallback to new chunk if the merge could not be performed.
+          chunk_path ||= save_compressed_chunk(
+            original_messages, compression_context[:recent_messages],
+            chunk_index: sm.next_chunk_index(@session_id, @created_at),
+            compression_level: compression_context[:compression_level], topics: topics
+          )
+          # The merged chunk is the current chunk — exclude it from previous_chunks.
+          index_chunks = existing_chunks.reject { |c| c[:index] == latest_chunk[:index] }
+        else
+          chunk_index = sm.next_chunk_index(@session_id, @created_at)
+          chunk_path = save_compressed_chunk(
+            original_messages,
+            compression_context[:recent_messages],
+            chunk_index: chunk_index,
+            compression_level: compression_context[:compression_level],
+            topics: topics
+          )
+          index_chunks = existing_chunks
+        end
 
         # Build previous_chunks index from the disk-discovered chunks (already
         # sorted by index ascending). This gives the new summary a complete
         # chronological index of all older archives so the AI can recall any
         # past chunk via file_reader, not just the most recent one.
-        previous_chunks = existing_chunks.map do |c|
+        previous_chunks = index_chunks.map do |c|
           { basename: c[:basename], path: c[:path], topics: c[:topics] }
         end
 
@@ -483,6 +520,62 @@ module Clacky
         nil
       end
 
+      # Merge the current batch of compressed messages INTO an existing chunk
+      # (overwrite-in-place, same chunk index). Used when the LLM judged this
+      # conversation as a continuation of the previous chunk's task. Keeps the
+      # archive on a single, growing, well-formed chunk instead of fragmenting
+      # into tiny standalone files that pollute the topics index.
+      #
+      # Every write hits disk immediately, so a crash never loses archived
+      # messages — there is no in-memory buffering.
+      #
+      # @param prev_chunk [Hash] disk-discovered chunk hash ({ index:, path:, topics: })
+      # @return [String, nil] the chunk path on success, nil if merge not possible
+      def merge_into_previous_chunk(prev_chunk, original_messages, recent_messages, compression_level:, topics: nil)
+        return nil unless @session_id && @created_at
+
+        recent_set = recent_messages.to_a
+        messages_to_archive = original_messages.reject do |m|
+          m[:role] == "system" || m[:system_injected] || m[:compressed_summary] || recent_set.include?(m)
+        end
+        return nil if messages_to_archive.empty?
+
+        sm = session_manager
+        raw = sm.read_chunk(prev_chunk[:path])
+        return nil unless raw
+
+        fm, body = sm.split_chunk_md(raw)
+        return nil unless fm
+
+        new_sections = render_message_sections(messages_to_archive)
+
+        fm["compression_level"] = compression_level.to_s
+        fm["archived_at"]       = Time.now.iso8601
+        fm["message_count"]     = (fm["message_count"].to_i + messages_to_archive.size).to_s
+        fm["merged_count"]      = (fm.fetch("merged_count", "1").to_i + 1).to_s
+        fm["topics"]            = merge_topics(fm["topics"], topics)
+
+        lines = ["---"]
+        fm.each { |k, v| lines << "#{k}: #{v}" }
+        lines << "---"
+        lines << body.rstrip
+        lines << ""
+        lines.concat(new_sections)
+
+        sm.write_chunk(@session_id, @created_at, prev_chunk[:index], lines.join("\n"))
+      rescue => e
+        @ui&.log("Failed to merge chunk MD: #{e.message}", level: :warn)
+        nil
+      end
+
+      # Union two comma-separated topic strings, preserving order, dropping dups.
+      private def merge_topics(existing, incoming)
+        a = (existing || "").split(/\s*,\s*/).map(&:strip).reject(&:empty?)
+        b = (incoming || "").split(/\s*,\s*/).map(&:strip).reject(&:empty?)
+        merged = (a + b).uniq
+        merged.empty? ? nil : merged.join(", ")
+      end
+
       # Build markdown content from a list of messages
       # @param messages [Array<Hash>] Messages to render
       # @param chunk_index [Integer] Chunk number for metadata
@@ -508,6 +601,15 @@ module Clacky
         lines << "> Use `file_reader` to recall specific details from this conversation."
         lines << ""
 
+        lines.concat(render_message_sections(messages))
+
+        lines.join("\n")
+      end
+
+      # Render messages into chunk MD body sections (no front matter / header).
+      # Shared by build_chunk_md and the chunk-merge path.
+      def render_message_sections(messages)
+        lines = []
         messages.each do |msg|
           role = msg[:role]
           content = msg[:content]
@@ -560,8 +662,7 @@ module Clacky
             lines << ""
           end
         end
-
-        lines.join("\n")
+        lines
       end
 
       # Format message content (handles string or array of content blocks)

data/lib/clacky/agent.rb

@@ -51,7 +51,7 @@ module Clacky
     attr_accessor :pinned
     attr_accessor :channel_info
 
-    REASONING_EFFORTS = %w[low medium high].freeze
+    REASONING_EFFORTS = %w[low medium high xhigh].freeze
 
     def permission_mode
       @config&.permission_mode&.to_s || ""
@@ -136,6 +136,8 @@ module Clacky
       # Free-mode counterpart: branded but not activated → fetch unencrypted skills
       # via the public endpoint so users get a working install with no serial number.
       @brand_config.sync_free_skills_async!
+      # Brand extensions bundled into the activated license's distribution.
+      @brand_config.sync_brand_extensions_async!
 
       # Initialize Time Machine
       init_time_machine
@@ -146,6 +148,11 @@ module Clacky
       # Load declarative shell hooks from ~/.clacky/hooks.yml
       ShellHookLoader.load_into(@hooks)
 
+      # Copy ext.yml-contributed hook callbacks (contributes.hooks) onto this
+      # agent's hook manager. The callbacks were registered process-wide at
+      # boot via ExtensionHookLoader.
+      ExtensionHookRegistry.apply_to(@hooks)
+
       # Ensure user-space parsers are in place (~/.clacky/parsers/)
       Utils::ParserManager.setup!
 
@@ -683,9 +690,6 @@ module Clacky
         raise
       ensure
         # Safety net: ensure any lingering progress spinner is stopped.
-        # Normal paths close their own spinners; this guards against exceptions
-        # raised between a progress slot's active/done pair.
-        Clacky::Logger.warn("[ph_debug] agent_run_ensure")
         @ui&.show_progress(phase: "done")
 
         # Fire-and-forget telemetry after every agent run.

data/lib/clacky/agent_profile.rb

@@ -6,107 +6,175 @@ module Clacky
   # Loads and represents an agent profile (system prompt + skill whitelist).
   #
   # Lookup order for a profile named "coding":
-  #   1. ~/.clacky/agents/coding/          (user override)
-  #   2. <gem>/lib/clacky/default_agents/coding/  (built-in default)
+  #   1. ~/.clacky/agents/coding/                (user override, physical dir)
+  #   2. extension agent unit with id == "coding" (ext.yml contributes.agents)
   #
-  # Each profile directory must contain:
+  # Each user profile directory (opt-in override) contains:
   #   - profile.yml       — name, description, skills whitelist
   #   - system_prompt.md  — agent-specific system prompt content
   #
-  # Global files (shared across all agents), also with user-override support:
-  #   - SOUL.md   — agent personality/values
-  #   - USER.md   — user profile information
-  #   - base_prompt.md — universal behavioral rules (todo manager, tool usage, etc.)
+  # Global files (shared across all agents) are user-only overrides:
+  #   - ~/.clacky/agents/SOUL.md   — agent personality/values (else DEFAULT_SOUL)
+  #   - ~/.clacky/agents/USER.md   — user profile info        (else DEFAULT_USER)
+  # The universal behavioural rules (todo manager, tool usage, response style,
+  # etc.) live in a bundled resource file at lib/clacky/prompts/base.md.
   class AgentProfile
-    DEFAULT_AGENTS_DIR = File.expand_path("../default_agents", __FILE__).freeze
     USER_AGENTS_DIR = File.expand_path("~/.clacky/agents").freeze
+    BASE_PROMPT_PATH = File.expand_path("../prompts/base.md", __FILE__).freeze
+
+    DEFAULT_SOUL = <<~MD.freeze
+      You are calm, precise, and helpful. You communicate clearly and concisely.
+      You are honest about uncertainty and ask for clarification when needed.
+      You take initiative but respect the user's preferences and decisions.
+    MD
+
+    DEFAULT_USER = "(No user profile configured yet. To personalize, create ~/.clacky/agents/USER.md)"
 
     attr_reader :name, :description
 
     def initialize(name)
       @name = name.to_s
+      result = ExtensionLoader.last_result
+      @ext_unit = result&.agents&.find { |u| u.id == @name }
+      if @ext_unit.nil?
+        result = ExtensionLoader.load_all(force: true)
+        @ext_unit = result&.agents&.find { |u| u.id == @name }
+      end
       profile_data = load_profile_yml
       @description = profile_data["description"] || ""
       @system_prompt_content = load_agent_file("system_prompt.md")
     end
 
-    # Load a named profile. Raises ArgumentError if profile directory not found.
     # @param name [String, Symbol] profile name (e.g. "coding", "general")
     # @return [AgentProfile]
     def self.load(name)
       new(name)
     end
 
+    # List all available agent profiles across user + extension layers.
+    # Precedence on id collision: user override → extension unit.
+    # @return [Array<Hash>] each: { id:, title:, title_zh:, description:, description_zh:, source:, order:, layer:, author: }
+    def self.all
+      out = {}
+
+      add = lambda do |id, title, title_zh, description, description_zh, source, order, layer, author|
+        next if id.nil? || id.empty?
+        out[id] = {
+          id: id,
+          title: title,
+          title_zh: title_zh,
+          description: description,
+          description_zh: description_zh,
+          source: source,
+          order: order,
+          layer: layer,
+          author: author,
+        }
+      end
+
+      ext_result = ExtensionLoader.last_result || ExtensionLoader.load_all
+      ext_result&.agents&.each do |unit|
+        spec = unit.spec || {}
+        title = spec["title"].to_s
+        title = unit.id if title.empty?
+        add.call(
+          unit.id, title, spec["title_zh"].to_s,
+          spec["description"].to_s, spec["description_zh"].to_s,
+          "extension", spec["order"], unit.layer.to_s,
+          spec["author"].to_s
+        )
+      end
+
+      Dir.glob(File.join(USER_AGENTS_DIR, "*")).sort.each do |path|
+        next unless File.directory?(path)
+        id = File.basename(path)
+        next if id.start_with?("_")
+        next unless File.file?(File.join(path, "profile.yml"))
+        meta = read_profile_yml(File.join(path, "profile.yml"))
+        add.call(
+          id, meta["title"] || meta["name"] || id, meta["title_zh"].to_s,
+          meta["description"].to_s, meta["description_zh"].to_s,
+          "user", meta["order"], "user",
+          meta["author"].to_s.empty? ? "You" : meta["author"].to_s
+        )
+      end
+
+      source_rank = { "user" => 0, "extension" => 1 }
+      out.values.sort_by { |a| [source_rank[a[:source]] || 9, a[:order] || 999, a[:id]] }
+    end
+
+    private_class_method def self.read_profile_yml(path)
+      return {} unless File.file?(path)
+      YAML.safe_load(File.read(path)) || {}
+    rescue StandardError
+      {}
+    end
+
     # @return [String] agent-specific system prompt content
     def system_prompt
       @system_prompt_content
     end
 
-    # @return [String] base prompt shared by all agents
+    # @return [String] base prompt shared by all agents (bundled resource)
     def base_prompt
-      load_global_file("base_prompt.md")
+      return "" unless File.file?(BASE_PROMPT_PATH)
+      File.read(BASE_PROMPT_PATH).strip
     end
 
-    # @return [String] soul content (user override → built-in default)
+    # @return [String] soul content (user override, else default)
     def soul
-      load_global_file("SOUL.md")
+      user_path = File.join(USER_AGENTS_DIR, "SOUL.md")
+      if File.exist?(user_path) && !File.zero?(user_path)
+        File.read(user_path).strip
+      else
+        DEFAULT_SOUL.strip
+      end
     end
 
-    # @return [String] user profile content (user override → built-in default)
+    # @return [String] user profile content (user override, else default)
     def user_profile
-      load_global_file("USER.md")
+      user_path = File.join(USER_AGENTS_DIR, "USER.md")
+      if File.exist?(user_path) && !File.zero?(user_path)
+        File.read(user_path).strip
+      else
+        DEFAULT_USER
+      end
     end
 
     private def load_profile_yml
-      path = find_agent_file("profile.yml")
-      raise ArgumentError, "Agent profile '#{@name}' not found. " \
-        "Looked in #{user_agent_dir} and #{default_agent_dir}" unless path
-
-      YAML.safe_load(File.read(path)) || {}
-    end
-
-    # Load a file from the agent-specific directory (user override → built-in)
-    private def load_agent_file(filename)
-      path = find_agent_file(filename)
-      return "" unless path
-
-      File.read(path).strip
-    end
-
-    # Load a global file shared across all agents (user override → built-in)
-    private def load_global_file(filename)
-      user_path = File.join(USER_AGENTS_DIR, filename)
-      default_path = File.join(DEFAULT_AGENTS_DIR, filename)
-
-      path = if File.exist?(user_path) && !File.zero?(user_path)
-               user_path
-             elsif File.exist?(default_path)
-               default_path
-             end
+      user_yml = File.join(user_agent_dir, "profile.yml")
+      if File.file?(user_yml)
+        return YAML.safe_load(File.read(user_yml)) || {}
+      end
 
-      return "" unless path
+      if @ext_unit
+        return {
+          "name"        => @name,
+          "description" => @ext_unit.spec["description"],
+          "panels"      => @ext_unit.spec["panels"],
+          "skills"      => @ext_unit.spec["skills"],
+        }
+      end
 
-      File.read(path).strip
+      raise ArgumentError, "Agent profile '#{@name}' not found. " \
+        "Looked in #{user_agent_dir} and extension registry."
     end
 
-    # Find a file in user override dir first, then built-in default dir
-    private def find_agent_file(filename)
+    # Agent-specific file lookup: user override → extension prompt (system_prompt.md only).
+    private def load_agent_file(filename)
       user_path = File.join(user_agent_dir, filename)
-      default_path = File.join(default_agent_dir, filename)
+      return File.read(user_path).strip if File.exist?(user_path) && !File.zero?(user_path)
 
-      if File.exist?(user_path) && !File.zero?(user_path)
-        user_path
-      elsif File.exist?(default_path)
-        default_path
+      if @ext_unit && filename == "system_prompt.md"
+        prompt_abs = @ext_unit.spec["prompt_abs"]
+        return File.read(prompt_abs).strip if prompt_abs && File.file?(prompt_abs)
       end
+
+      ""
     end
 
     private def user_agent_dir
       File.join(USER_AGENTS_DIR, @name)
     end
-
-    private def default_agent_dir
-      File.join(DEFAULT_AGENTS_DIR, @name)
-    end
   end
 end