openclacky 0.9.30 → 0.9.32

data/lib/clacky/default_skills/skill-creator/SKILL.md

@@ -7,6 +7,15 @@ description: Create new skills, modify and improve existing skills, and measure
 
 A skill for creating new skills and iteratively improving them.
 
+## Usage Modes
+
+This skill supports two modes:
+
+### 1. Interactive Mode (default)
+
+The full workflow with user interviews, test cases, and iteration cycles.
+Use when creating or refining skills manually.
+
 At a high level, the process of creating a skill goes like this:
 
 - Decide what you want the skill to do and roughly how it should do it
@@ -22,6 +31,43 @@ Your job is to figure out where the user is in this process and jump in to help
 
 Always be flexible. If the user says "skip the evals, just vibe with me", do that instead.
 
+### 2. Quick Mode (for agent self-evolution)
+
+**Trigger**: When invoked with `mode: "quick"` in the task arguments.
+
+Fast, opinionated skill creation without user interaction. This mode is used by the agent's self-evolution system to automatically create or improve skills.
+
+**Behavior**:
+- Skip user interviews and detailed requirements gathering
+- Extract workflow pattern from provided context
+- Write a minimal but functional SKILL.md
+- Save to `~/.clacky/skills/auto-<name>-<timestamp>/` (or improve existing skill in place)
+- Skip test cases and evals (user can refine later if needed)
+- Always validate frontmatter with the validator script after creation
+- Focus on the happy path; edge cases can be added later
+
+**Expected arguments when using quick mode**:
+- `task`: Clear description of what to automate and how (be specific about workflow steps)
+- `mode`: Must be set to `"quick"`
+- `suggested_name`: (optional) Proposed skill identifier (lowercase, hyphens OK)
+
+**Quick mode principles**:
+- **Be opinionated**: Make reasonable assumptions without asking
+- **Be concise**: Keep instructions simple and focused
+- **Be practical**: Focus on the core workflow that will save the most time
+- **Be correct**: Always set `disable-model-invocation: false` and `user-invocable: true`
+- **Be validating**: Run the frontmatter validator immediately after creation
+
+**Example invocation from the agent's self-evolution system**:
+```
+invoke_skill(
+  skill_name: "skill-creator",
+  task: "Create a skill to extract and summarize content from URLs. The skill should: 1) fetch the URL using safe_shell with curl, 2) parse the HTML to extract main text content, 3) generate a concise markdown summary. Expected input: URL string. Expected output: markdown summary with title and key points.",
+  mode: "quick",
+  suggested_name: "url-summarizer"
+)
+```
+
 ---
 
 ## Platform Context: Clacky

data/lib/clacky/json_ui_controller.rb

@@ -132,10 +132,6 @@ module Clacky
       @progress_start_time = nil if phase == "done"
     end
 
-    def clear_progress
-      show_progress(progress_type: "thinking", phase: "done")
-    end
-
     # === State updates ===
 
     def update_sessionbar(tasks: nil, cost: nil, status: nil)

data/lib/clacky/message_history.rb

@@ -62,12 +62,6 @@ module Clacky
       @messages.pop
     end
 
-    # Remove messages from the end while the block is truthy.
-    def pop_while(&block)
-      @messages.pop while !@messages.empty? && block.call(@messages.last)
-      self
-    end
-
     # Remove all messages matching the block in-place
     # (e.g. cleanup_memory_messages uses reject! { m[:memory_update] }).
     def delete_where(&block)
@@ -152,12 +146,6 @@ module Clacky
       @messages.select { |m| !m[:task_id] || m[:task_id] <= task_id }
     end
 
-    # Count how many of the last N messages have :truncated set.
-    # Used by think() to guard against infinite truncation retry loops.
-    def recent_truncation_count(n)
-      @messages.last(n).count { |m| m[:truncated] }
-    end
-
     # ─────────────────────────────────────────────
     # Size helpers
     # ─────────────────────────────────────────────

data/lib/clacky/plain_ui_controller.rb

@@ -23,6 +23,25 @@ module Clacky
 
     def show_tool_call(name, args)
       args_data = args.is_a?(String) ? (JSON.parse(args) rescue args) : args
+
+      # Special handling for request_user_feedback — display as a readable prompt
+      if name.to_s == "request_user_feedback"
+        question = args_data.is_a?(Hash) ? (args_data[:question] || args_data["question"]).to_s : ""
+        context  = args_data.is_a?(Hash) ? (args_data[:context]  || args_data["context"]).to_s  : ""
+        options  = args_data.is_a?(Hash) ? (args_data[:options]  || args_data["options"])        : nil
+        options  = Array(options) if options && !options.is_a?(Array)
+
+        parts = []
+        parts << "**Context:** #{context.strip}" if context && !context.strip.empty?
+        parts << "**Question:** #{question.strip}"
+        if options && !options.empty?
+          parts << "**Options:**"
+          options.each_with_index { |opt, i| parts << "  #{i + 1}. #{opt}" }
+        end
+        puts_line(parts.join("\n"))
+        return
+      end
+
       display = case name
                 when "shell", "safe_shell"
                   cmd = args_data.is_a?(Hash) ? (args_data[:command] || args_data["command"]) : args_data
@@ -107,7 +126,6 @@ module Clacky
     # === Progress (no-ops — no spinner in plain mode) ===
 
     def show_progress(message = nil, prefix_newline: true, progress_type: "thinking", phase: "active", metadata: {}); end
-    def clear_progress; end
 
     # === State updates (no-ops) ===
 

data/lib/clacky/platform_http_client.rb

@@ -9,8 +9,6 @@ module Clacky
   # OpenClacky platform API (www.openclacky.com and its fallback domain).
   #
   # Features:
-  #   - Primary domain:  https://www.openclacky.com  (EdgeOne CDN-accelerated)
-  #   - Fallback domain: https://openclacky-platform.clackyai.app  (direct, no CDN)
   #   - Automatic retry with exponential back-off on transient failures
   #   - Transparent domain failover: if the primary domain times out or returns a
   #     5xx error, the request is automatically retried against the fallback domain
@@ -23,9 +21,9 @@ module Clacky
   #   #        or { success: false, error: "...", data: {} }
   class PlatformHttpClient
     # Primary CDN-accelerated endpoint
-    PRIMARY_HOST   = "https://www.openclacky.com"
+    PRIMARY_HOST  = "https://www.openclacky.com"
     # Direct fallback — bypasses EdgeOne, used when the primary times out
-    FALLBACK_HOST  = "https://openclacky-platform.clackyai.app"
+    FALLBACK_HOST = "https://openclacky.up.railway.app"
 
     # Number of attempts per domain (1 = no retry within the same domain)
     ATTEMPTS_PER_HOST = 2

data/lib/clacky/providers.rb

@@ -18,6 +18,7 @@ module Clacky
         "default_model" => "abs-claude-sonnet-4-5",
         "lite_model" => "abs-claude-haiku-4-5",
         "models" => [
+          "abs-claude-opus-4-7",
           "abs-claude-opus-4-6",
           "abs-claude-sonnet-4-6",
           "abs-claude-sonnet-4-5",
@@ -63,7 +64,7 @@ module Clacky
         "base_url" => "https://api.anthropic.com",
         "api" => "anthropic-messages",
         "default_model" => "claude-sonnet-4.6",
-        "models" => ["claude-opus-4-6", "claude-sonnet-4.6", "claude-haiku-4.5"],
+        "models" => ["claude-opus-4-7", "claude-opus-4-6", "claude-sonnet-4.6", "claude-haiku-4.5"],
         "website_url" => "https://console.anthropic.com/settings/keys"
       }.freeze,
 
@@ -74,6 +75,7 @@ module Clacky
         "default_model" => "abs-claude-sonnet-4-5",
         "lite_model" => "abs-claude-haiku-4-5",
         "models" => [
+          "abs-claude-opus-4-7",
           "abs-claude-opus-4-6",
           "abs-claude-sonnet-4-6",
           "abs-claude-sonnet-4-5",
@@ -94,6 +96,15 @@ module Clacky
         "default_model" => "mimo-v2-pro",
         "models" => ["mimo-v2-pro", "mimo-v2-omni"],
         "website_url" => "https://platform.xiaomimimo.com/"
+      }.freeze,
+
+      "glm" => {
+        "name" => "GLM (ZhipuAI)",
+        "base_url" => "https://open.bigmodel.cn/api/paas/v4",
+        "api" => "openai-completions",
+        "default_model" => "glm-5.1",
+        "models" => ["glm-5.1", "glm-5", "glm-5-turbo", "glm-5v-turbo", "glm-4.7"],
+        "website_url" => "https://open.bigmodel.cn/usercenter/apikeys"
       }.freeze
 
     }.freeze

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

@@ -142,8 +142,6 @@ module Clacky
         # Suppress — progress spinner has no IM equivalent
       end
 
-      def clear_progress; end
-
       # === State updates (no-ops for IM) ===
 
       def update_sessionbar(tasks: nil, cost: nil, status: nil); end

data/lib/clacky/server/http_server.rb

@@ -281,7 +281,7 @@ module Clacky
 
         server.mount_proc("/") do |req, res|
           if req.path == "/" || req.path == "/index.html"
-            product_name = Clacky::BrandConfig.load.product_name || "Clacky"
+            product_name = Clacky::BrandConfig.load.product_name || "OpenClacky"
             html = File.read(index_html_path).gsub("{{BRAND_NAME}}", product_name)
             res.status                = 200
             res["Content-Type"]       = "text/html; charset=utf-8"
@@ -375,6 +375,7 @@ module Clacky
         when ["GET",    "/api/store/skills"]          then api_store_skills(res)
         when ["GET",    "/api/brand/status"]      then api_brand_status(res)
         when ["POST",   "/api/brand/activate"]    then api_brand_activate(req, res)
+        when ["DELETE", "/api/brand/license"]     then api_brand_deactivate(res)
         when ["GET",    "/api/brand/skills"]      then api_brand_skills(res)
         when ["GET",    "/api/brand"]             then api_brand_info(res)
         when ["GET",    "/api/creator/skills"]    then api_creator_skills(res)
@@ -680,6 +681,17 @@ module Clacky
         end
       end
 
+      # DELETE /api/brand/license
+      # Deactivates (unbinds) the current brand license and clears all brand state.
+      # Brand skills are removed from disk. Returns 200 on success.
+      private def api_brand_deactivate(res)
+        brand  = Clacky::BrandConfig.load
+        result = brand.deactivate!
+        # Reload skill_loader without brand config so brand skills are no longer visible.
+        @skill_loader = Clacky::SkillLoader.new(working_dir: nil, brand_config: Clacky::BrandConfig.new({}))
+        json_response(res, 200, { ok: true })
+      end
+
       # GET /api/brand/skills
       # Fetches the brand skills list from the cloud, enriched with local installed version.
       # Returns 200 with skill list, or 403 when license is not activated.

data/lib/clacky/server/web_ui_controller.rb

@@ -92,11 +92,25 @@ module Clacky
       end
 
       def show_tool_call(name, args)
-        # Skip request_user_feedback — its question is already shown as an assistant message
-        return if name.to_s == "request_user_feedback"
-
         args_data = args.is_a?(String) ? (JSON.parse(args) rescue args) : args
 
+        # Special handling for request_user_feedback — emit a dedicated UI event
+        if name.to_s == "request_user_feedback"
+          question = args_data.is_a?(Hash) ? (args_data[:question] || args_data["question"]).to_s : ""
+          context  = args_data.is_a?(Hash) ? (args_data[:context]  || args_data["context"]).to_s  : ""
+          options  = args_data.is_a?(Hash) ? (args_data[:options]  || args_data["options"])        : nil
+
+          # Normalize options to array (guard against malformed data)
+          options = Array(options) if options && !options.is_a?(Array)
+
+          emit("request_feedback",
+               question: question,
+               context: context,
+               options: options || [])
+          # Don't forward to IM subscribers — they get the formatted text version already
+          return
+        end
+
         # Generate a human-readable summary using the tool's format_call method
         summary = tool_call_summary(name, args_data)
 
@@ -179,13 +193,6 @@ module Clacky
         forward_to_subscribers { |sub| sub.show_info(message) }
       end
 
-      # Emit a two-phase idle compression status update.
-      # The frontend uses the same DOM element for both phases so it renders as one line.
-      # phase: :start → show spinner message; phase: :end → update in-place with final result
-      def show_idle_status(phase:, message:)
-        emit("idle_status", phase: phase.to_s, message: message)
-      end
-
       def show_warning(message)
         emit("warning", message: message)
         forward_to_subscribers { |sub| sub.show_warning(message) }
@@ -209,10 +216,23 @@ module Clacky
       # === Progress ===
 
       def show_progress(message = nil, prefix_newline: true, progress_type: "thinking", phase: "active", metadata: {})
-        @progress_start_time = Time.now if phase == "active"
-        @live_progress_message = message
-        # Reset stdout buffer for each new command so re-subscribe only replays current run
-        @live_stdout_buffer = [] if phase == "active"
+        if phase == "active"
+          @progress_start_time = Time.now
+          # Store complete progress state for replay when user switches back to this session
+          @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.
+          # This allows a brief replay window even after the command finishes.
+          @live_progress_state = nil
+          @progress_start_time = nil
+        end
         
         data = {
           message: message,
@@ -221,12 +241,15 @@ module Clacky
           status: phase == "active" ? "start" : "stop"  # backward compat
         }
         data[:metadata] = metadata unless metadata.empty?
+        # Always include started_at for "active" phase so the frontend can set the
+        # correct timer origin even on the very first event (not just replay).
+        if phase == "active" && @progress_start_time
+          data[:started_at] = (@progress_start_time.to_f * 1000).round
+        end
         data[:elapsed] = (Time.now - @progress_start_time).round(1) if phase == "done" && @progress_start_time
         
         emit("progress", **data)
         forward_to_subscribers { |sub| sub.show_progress(message) }
-        
-        @progress_start_time = nil if phase == "done"
       end
 
       # Stream shell stdout/stderr lines to the browser while a command is running.
@@ -241,17 +264,7 @@ module Clacky
         # Not forwarded to IM subscribers — too noisy
       end
 
-      def clear_progress
-        @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.
-        # This allows a brief replay window even after the command finishes.
-        show_progress(progress_type: "thinking", phase: "done")
-      end
-
       # Replay in-progress command state to a newly (re-)subscribing browser tab.
-      # Called by http_server.rb after the subscribe handshake when the session
-      # is still running a shell command.  Without this, switching sessions and
-      # switching back results in a blank progress area — the progress event and
       # all tool_stdout lines that fired while the user was away are lost.
       # Replay live state when a client re-subscribes (e.g. after switching sessions).
       #
@@ -264,9 +277,22 @@ module Clacky
       # The frontend's appendToolStdout will attach to the last visible .tool-item
       # even when _liveLastToolItem is null (after the tab re-loaded).
       def replay_live_state
-        return unless @live_progress_message
-
-        emit("progress", message: @live_progress_message, status: "start")
+        return unless @live_progress_state
+
+        # Replay complete progress state (not just message).
+        # Include started_at (ms since epoch) so the frontend can resume the
+        # elapsed-time counter from the correct origin instead of resetting to 0.
+        state = @live_progress_state
+        started_at_ms = @progress_start_time ? (@progress_start_time.to_f * 1000).round : nil
+
+        emit("progress",
+          message: state[:message],
+          progress_type: state[:progress_type],
+          phase: "active",
+          status: "start",
+          metadata: state[:metadata] || {},
+          started_at: started_at_ms
+        )
 
         buf = @live_stdout_buffer
         emit("tool_stdout", lines: buf) if buf && !buf.empty?