openclacky 1.0.3 → 1.0.5

data/lib/clacky/default_skills/persist-memory/SKILL.md

@@ -0,0 +1,59 @@
+---
+name: persist-memory
+description: Persist information to long-term memory at ~/.clacky/memories/. Use when the user asks you to remember/note something, or when reviewing a finished conversation for facts worth keeping. Handles file naming, topic merging, frontmatter, and size limits.
+fork_agent: true
+user-invocable: false
+auto_summarize: true
+forbidden_tools:
+  - web_search
+  - web_fetch
+  - browser
+---
+
+# Persist Memory Subagent
+
+You are a **Memory Persistence Subagent** — a pure executor. The caller has already decided that something must be written. Your job is to write it correctly: pick the right file, merge with existing content, respect the size limit.
+
+You do NOT decide whether to write. If the task description tells you to persist X, you persist X.
+
+## Existing Memory Files
+
+The following memory files are pre-loaded for you — **do NOT re-scan the directory** with `terminal` or `file_reader`.
+
+<%= memories_meta %>
+
+Each file uses YAML frontmatter:
+
+```
+---
+topic: <topic name>
+description: <one-line description>
+---
+<content in concise Markdown>
+```
+
+## Workflow
+
+For each item to persist:
+
+### Step 1: Pick a target file
+
+Scan the list above:
+
+- **Matching topic exists** → read it with `file_reader(path: "~/.clacky/memories/<filename>")`, integrate the new info, drop stale parts, then `write` the updated version back.
+- **No match** → create a new file at `~/.clacky/memories/<topic-slug>.md`.
+  - Slug: lowercase, hyphen-separated, descriptive (e.g. `deployment-target.md`, `code-style-preferences.md`).
+
+### Step 2: Write the file
+
+Use the `write` tool. Always include the YAML frontmatter shown above.
+
+## Hard constraints (CRITICAL)
+
+- Each file MUST stay under **4000 characters of content** (after the frontmatter).
+- If merging would exceed this limit, remove the least important information — do NOT split into multiple files for the same topic.
+- Write concise, factual Markdown — no fluff, no redundant headings.
+- One topic per file. Don't bundle unrelated facts together.
+- Do NOT use `terminal` or `file_reader` to list the memories directory — the list above is authoritative.
+
+When done, briefly state what was written (e.g. "Updated deployment-target.md") or `No memory updates needed.` if the task description didn't actually require any writes.

data/lib/clacky/providers.rb

@@ -29,7 +29,7 @@ module Clacky
         "name" => "OpenClacky",
         "base_url" => "https://api.openclacky.com",
         "api" => "bedrock",
-        "default_model" => "abs-claude-sonnet-4-5",
+        "default_model" => "abs-claude-sonnet-4-6",
         "models" => [
           "abs-claude-opus-4-7",
           "abs-claude-opus-4-6",
@@ -80,7 +80,32 @@ module Clacky
         "base_url" => "https://openrouter.ai/api/v1",
         "api" => "openai-responses",
         "default_model" => "anthropic/claude-sonnet-4-6",
-        "models" => [],  # Dynamic - fetched from API
+        # Curated default lineup. OpenRouter's full catalogue is enormous
+        # (hundreds of models) and the live /models endpoint isn't always
+        # reachable from every region — shipping a small list of the
+        # mainstream Claude + GPT entries gives users a working dropdown
+        # out of the box. Users can still type any other OpenRouter model
+        # ID manually; this list only seeds the picker.
+        "models" => [
+          "anthropic/claude-sonnet-4-6",
+          "anthropic/claude-opus-4-7",
+          "anthropic/claude-opus-4-6",
+          "anthropic/claude-haiku-4-5",
+          "openai/gpt-5.5",
+          "openai/gpt-5.4",
+          "openai/gpt-5.4-mini"
+        ],
+        # Per-primary lite pairing — Claude family pairs with Haiku, GPT
+        # family pairs with the mini variant. Mirrors the openclacky and
+        # openai presets above so subagents on OpenRouter get a sensible
+        # cheap/fast sidekick automatically.
+        "lite_models" => {
+          "anthropic/claude-sonnet-4-6" => "anthropic/claude-haiku-4-5",
+          "anthropic/claude-opus-4-7"   => "anthropic/claude-haiku-4-5",
+          "anthropic/claude-opus-4-6"   => "anthropic/claude-haiku-4-5",
+          "openai/gpt-5.5"              => "openai/gpt-5.4-mini",
+          "openai/gpt-5.4"              => "openai/gpt-5.4-mini"
+        },
         # Per-model API type overrides. Matched by Regexp against the model name.
         # Why this exists: OpenRouter proxies Claude via both its OpenAI-compatible
         # /chat/completions endpoint AND a native Anthropic /v1/messages endpoint.
@@ -146,12 +171,16 @@ module Clacky
         "default_model" => "kimi-k2.6",
         "models" => ["kimi-k2.6", "kimi-k2.5"],
         # Moonshot operates two regional endpoints with identical APIs & model
-        # lineup — mainland China (.cn) and international (.ai). Kimi does not
-        # distinguish pay-as-you-go vs coding-plan at the base_url level, so
-        # only two variants are needed. Listing both here lets find_by_base_url
-        # identify either one as provider "kimi", so downstream capability
-        # checks, fallback chains, and provider-specific behaviours work
-        # regardless of which endpoint the user configured.
+        # lineup — mainland China (.cn) and international (.ai). These are the
+        # pay-as-you-go Open Platform endpoints; the subscription-billed
+        # Coding Plan lives at api.kimi.com/coding with the unified
+        # `kimi-for-coding` model alias and is exposed as a separate
+        # top-level "kimi-coding" preset (different domain, distinct billing
+        # model, marketed by Moonshot as the standalone Kimi Code product).
+        # Listing both PAYG variants here lets find_by_base_url identify
+        # either one as provider "kimi", so downstream capability checks,
+        # fallback chains, and provider-specific behaviours work regardless
+        # of which endpoint the user configured.
         "endpoint_variants" => [
           { "label" => "Mainland China", "label_key" => "settings.models.baseurl.variant.mainland_cn",   "base_url" => "https://api.moonshot.cn/v1", "region" => "cn"   }.freeze,
           { "label" => "International",  "label_key" => "settings.models.baseurl.variant.international", "base_url" => "https://api.moonshot.ai/v1", "region" => "intl" }.freeze
@@ -161,6 +190,44 @@ module Clacky
         "website_url" => "https://platform.moonshot.cn/console/api-keys"
       }.freeze,
 
+      "kimi-coding" => {
+        "name" => "Kimi Code (Coding Plan)",
+        # Subscription-billed Kimi Code endpoint — separate product from the
+        # PAYG Moonshot Open Platform (api.moonshot.cn/v1 / .ai/v1). Uses the
+        # unified `kimi-for-coding` model alias which the Coding Plan backend
+        # routes to the appropriate K2 variant (Kimi-k2.6 today; 262K context,
+        # 32K max output, supports vision/video/reasoning).
+        #
+        # Why anthropic-messages: Moonshot exposes the Coding Plan via two
+        # URLs on the same domain — an Anthropic-format endpoint at
+        # api.kimi.com/coding/ (used by Claude Code via ANTHROPIC_BASE_URL)
+        # and an OpenAI-compatible endpoint at api.kimi.com/coding/v1 (used
+        # by Roo Code etc.). We route through anthropic-messages so
+        # cache_control fields round-trip byte-for-byte (the OpenAI shim is
+        # lossy for cache_control semantics — see OpenRouter preset above
+        # for the same reason). Verified against the live endpoint: response
+        # payload includes cache_creation_input_tokens / cache_read_input_tokens,
+        # so the cache layer is real on this backend.
+        #
+        # User-Agent gate: this endpoint enforces a UA-prefix whitelist
+        # limited to first-party coding agents (Kimi CLI, Claude Code, Roo
+        # Code, Kilo Code, ...). Requests carrying openclacky's default
+        # Faraday UA are rejected with HTTP 403 access_terminated_error.
+        # Client#anthropic_connection injects a Claude Code-shaped UA when
+        # @provider_id == "kimi-coding" — see the comment in client.rb for
+        # the policy rationale.
+        #
+        # Source: https://www.kimi.com/code/docs/third-party-tools/other-coding-agents.html
+        "base_url" => "https://api.kimi.com/coding",
+        "api" => "anthropic-messages",
+        "default_model" => "kimi-for-coding",
+        "models" => ["kimi-for-coding"],
+        # K2.6 backend behind the alias is multimodal (image + video input,
+        # reasoning). Same vision capability as the PAYG kimi preset.
+        "capabilities" => { "vision" => true }.freeze,
+        "website_url" => "https://www.kimi.com/code"
+      }.freeze,
+
       "anthropic" => {
         "name" => "Anthropic (Claude)",
         "base_url" => "https://api.anthropic.com",
@@ -201,8 +268,8 @@ module Clacky
         "name" => "MiMo (Xiaomi)",
         "base_url" => "https://api.xiaomimimo.com/v1",
         "api" => "openai-completions",
-        "default_model" => "mimo-v2-pro",
-        "models" => ["mimo-v2-pro", "mimo-v2-omni"],
+        "default_model" => "mimo-v2.5-pro",
+        "models" => ["mimo-v2.5-pro", "mimo-v2-pro", "mimo-v2-omni"],
         # MiMo-V2-Pro is text-only; MiMo-V2-Omni supports vision (omni = multimodal).
         "capabilities" => { "vision" => false }.freeze,
         "model_capabilities" => {

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

@@ -0,0 +1,229 @@
+# frozen_string_literal: true
+
+require_relative "../../adapters/base"
+require_relative "api_client"
+require_relative "gateway_client"
+require_relative "../feishu/file_processor"
+require "time"
+
+module Clacky
+  module Channel
+    module Adapters
+      module Discord
+        # Discord adapter (bot mode).
+        # Receives messages via the Gateway WebSocket and sends via the REST API.
+        class Adapter < Base
+          MAX_IMAGE_BYTES = Clacky::Utils::FileProcessor::MAX_IMAGE_BYTES
+
+          def self.platform_id
+            :discord
+          end
+
+          def self.env_keys
+            %w[IM_DISCORD_BOT_TOKEN]
+          end
+
+          def self.platform_config(data)
+            {
+              bot_token: data["IM_DISCORD_BOT_TOKEN"]
+            }
+          end
+
+          def self.set_env_data(data, config)
+            data["IM_DISCORD_BOT_TOKEN"] = config[:bot_token]
+          end
+
+          def self.test_connection(fields)
+            bot_token = fields[:bot_token].to_s.strip
+            return { ok: false, error: "bot_token is required" } if bot_token.empty?
+
+            client = ApiClient.new(bot_token: bot_token)
+            me     = client.me
+            if me["id"]
+              { ok: true, message: "Connected as #{me["username"]}##{me["discriminator"]} (id=#{me["id"]})" }
+            else
+              { ok: false, error: "Empty response from /users/@me" }
+            end
+          rescue ApiClient::ApiError => e
+            { ok: false, error: e.message }
+          rescue StandardError => e
+            { ok: false, error: e.message }
+          end
+
+          def initialize(config)
+            @config       = config
+            @bot_token    = config[:bot_token]
+            @api          = ApiClient.new(bot_token: @bot_token)
+            @gateway      = GatewayClient.new(bot_token: @bot_token)
+            @bot_user_id  = nil
+            @running      = false
+            @on_message   = nil
+          end
+
+          def start(&on_message)
+            @running    = true
+            @on_message = on_message
+
+            begin
+              me = @api.me
+              @bot_user_id = me["id"]
+              Clacky::Logger.info("[DiscordAdapter] authenticated as #{me["username"]} (id=#{@bot_user_id})")
+            rescue ApiClient::ApiError => e
+              Clacky::Logger.error("[DiscordAdapter] /users/@me failed, not retrying: #{e.message}")
+              return
+            end
+
+            @gateway.start do |evt|
+              handle_gateway_event(evt)
+            end
+          rescue GatewayClient::AuthError => e
+            Clacky::Logger.error("[DiscordAdapter] Authentication failed, not retrying: #{e.message}")
+          end
+
+          def stop
+            @running = false
+            @gateway.stop
+          end
+
+          def send_text(chat_id, text, reply_to: nil)
+            res = @api.send_message(chat_id, text, reply_to: reply_to)
+            { message_id: res["id"] }
+          rescue ApiClient::ApiError => e
+            Clacky::Logger.error("[DiscordAdapter] send_text failed: #{e.message}")
+            { message_id: nil }
+          end
+
+          def update_message(chat_id, message_id, text)
+            @api.edit_message(chat_id, message_id, text)
+            true
+          rescue ApiClient::ApiError => e
+            Clacky::Logger.warn("[DiscordAdapter] update_message failed: #{e.message}")
+            false
+          end
+
+          def supports_message_updates?
+            true
+          end
+
+          def send_file(chat_id, path, name: nil)
+            @api.send_file(chat_id, path, name: name)
+          rescue ApiClient::ApiError => e
+            Clacky::Logger.error("[DiscordAdapter] send_file failed: #{e.message}")
+            nil
+          end
+
+          def validate_config(config)
+            errors = []
+            errors << "bot_token is required" if config[:bot_token].nil? || config[:bot_token].empty?
+            errors
+          end
+
+          private def handle_gateway_event(evt)
+            return unless evt[:type] == :message
+            handle_message(evt[:data])
+          end
+
+          private def handle_message(msg)
+            return if msg.nil?
+            author = msg["author"] || {}
+
+            return if author["bot"] == true
+            return if @bot_user_id && author["id"] == @bot_user_id
+
+            chat_id   = msg["channel_id"]
+            return unless chat_id
+
+            user_id   = author["id"]
+            chat_type = msg["guild_id"] ? :group : :direct
+            mentioned_ids = Array(msg["mentions"]).map { |m| m["id"] }
+
+            if chat_type == :group
+              if @bot_user_id.nil?
+                Clacky::Logger.warn("[DiscordAdapter] bot_user_id unavailable; dropping group message")
+                return
+              end
+              return unless mentioned_ids.include?(@bot_user_id)
+            end
+
+            allowed_users = @config[:allowed_users]
+            if allowed_users && !allowed_users.empty?
+              return unless allowed_users.include?(user_id)
+            end
+
+            text  = strip_bot_mention(msg["content"].to_s, @bot_user_id)
+            files = process_attachments(Array(msg["attachments"]), chat_id)
+
+            return if text.strip.empty? && files.empty?
+
+            event = {
+              type: :message,
+              platform: :discord,
+              chat_id: chat_id,
+              user_id: user_id,
+              text: text,
+              files: files,
+              message_id: msg["id"],
+              timestamp: parse_timestamp(msg["timestamp"]),
+              chat_type: chat_type,
+              mentioned_user_ids: mentioned_ids,
+              raw: msg
+            }
+
+            @on_message&.call(event)
+          rescue => e
+            Clacky::Logger.error("[DiscordAdapter] handle_message error: #{e.message}\n#{e.backtrace.first(3).join("\n")}")
+            begin
+              chat_id ||= msg && msg["channel_id"]
+              @api.send_message(chat_id, "Error processing message: #{e.message}") if chat_id
+            rescue
+              nil
+            end
+          end
+
+          private def strip_bot_mention(text, bot_id)
+            return text if bot_id.nil? || text.empty?
+            text.gsub(/<@!?#{Regexp.escape(bot_id)}>/, "").strip
+          end
+
+          private def process_attachments(attachments, chat_id)
+            files = []
+            attachments.each do |att|
+              url      = att["url"]
+              filename = att["filename"] || "attachment"
+              next unless url
+
+              result = @api.download(url)
+              body   = result[:body]
+              mime   = att["content_type"] || result[:content_type]
+
+              if mime && mime.start_with?("image/")
+                if body.bytesize > MAX_IMAGE_BYTES
+                  @api.send_message(chat_id, "Image too large (#{(body.bytesize / 1024.0).round(0).to_i}KB), max #{MAX_IMAGE_BYTES / 1024}KB")
+                  next
+                end
+                require "base64"
+                data_url = "data:#{mime};base64,#{Base64.strict_encode64(body)}"
+                files << { name: filename, mime_type: mime, data_url: data_url }
+              else
+                files << Clacky::Utils::FileProcessor.save(body: body, filename: filename)
+              end
+            end
+            files
+          rescue => e
+            Clacky::Logger.warn("[DiscordAdapter] process_attachments error: #{e.message}")
+            files
+          end
+
+          private def parse_timestamp(iso)
+            return Time.now if iso.nil? || iso.empty?
+            Time.iso8601(iso)
+          rescue ArgumentError
+            Time.now
+          end
+        end
+
+        Adapters.register(:discord, Adapter)
+      end
+    end
+  end
+end

data/lib/clacky/server/channel/adapters/discord/api_client.rb

@@ -0,0 +1,107 @@
+# frozen_string_literal: true
+
+require "faraday"
+require "json"
+
+module Clacky
+  module Channel
+    module Adapters
+      module Discord
+        class ApiClient
+          DEFAULT_HOMEPAGE_URL = "https://discord.com"
+          BASE_URL             = "#{DEFAULT_HOMEPAGE_URL}/api/v10/"
+
+          class ApiError < StandardError; end
+
+          def initialize(bot_token:)
+            @bot_token = bot_token
+            @conn = Faraday.new(url: BASE_URL) do |f|
+              f.headers["Authorization"] = "Bot #{@bot_token}"
+              f.headers["User-Agent"]    = self.class.user_agent
+              f.response :raise_error
+              f.adapter Faraday.default_adapter
+            end
+          end
+
+          def me
+            request(:get, "users/@me")
+          end
+
+          def send_message(channel_id, content, reply_to: nil)
+            payload = { content: content.to_s }
+            payload[:message_reference] = { message_id: reply_to.to_s } if reply_to
+            request(:post, "channels/#{channel_id}/messages", payload)
+          end
+
+          def edit_message(channel_id, message_id, content)
+            request(:patch, "channels/#{channel_id}/messages/#{message_id}", { content: content.to_s })
+          end
+
+          def send_file(channel_id, path, name: nil)
+            raise ArgumentError, "File not found: #{path}" unless File.exist?(path)
+            filename = name || File.basename(path)
+            payload  = { attachments: [{ id: 0, filename: filename }] }
+            io       = Faraday::UploadIO.new(path, detect_mime(path), filename)
+
+            res = @conn.post("channels/#{channel_id}/messages") do |req|
+              req.body = { "payload_json" => JSON.generate(payload), "files[0]" => io }
+            end
+            parse_json(res.body)
+          rescue Faraday::Error => e
+            raise_api_error(e)
+          end
+
+          def download(url)
+            res = Faraday.get(url)
+            { body: res.body, content_type: res.headers["content-type"] }
+          end
+
+          # Discord requires User-Agent of the form "DiscordBot ($url, $versionNumber)".
+          # Requests with an invalid UA may be blocked at Cloudflare.
+          def self.user_agent
+            url = (Clacky::BrandConfig.load.homepage_url rescue nil) || DEFAULT_HOMEPAGE_URL
+            "DiscordBot (#{url}, #{Clacky::VERSION})"
+          end
+
+          private def request(verb, path, body = nil)
+            res = @conn.run_request(verb, path, body ? JSON.generate(body) : nil,
+                                    { "Content-Type" => "application/json" })
+            parse_json(res.body)
+          rescue Faraday::Error => e
+            raise_api_error(e)
+          end
+
+          private def raise_api_error(err)
+            status = err.response&.dig(:status)
+            body   = err.response&.dig(:body).to_s
+            parsed = (JSON.parse(body) rescue nil)
+            msg    = (parsed.is_a?(Hash) && parsed["message"]) || err.message
+            raise ApiError, "Discord API #{status}: #{msg}"
+          end
+
+          private def parse_json(body)
+            return {} if body.to_s.empty?
+            JSON.parse(body)
+          rescue JSON::ParserError => e
+            raise ApiError, "Invalid JSON response: #{e.message}"
+          end
+
+          private def detect_mime(path)
+            case File.extname(path).downcase
+            when ".jpg", ".jpeg" then "image/jpeg"
+            when ".png"          then "image/png"
+            when ".gif"          then "image/gif"
+            when ".webp"         then "image/webp"
+            when ".mp4"          then "video/mp4"
+            when ".mp3"          then "audio/mpeg"
+            when ".pdf"          then "application/pdf"
+            when ".txt"          then "text/plain"
+            when ".json"         then "application/json"
+            else                      "application/octet-stream"
+            end
+          end
+        end
+      end
+    end
+  end
+end