ask-channel-providers 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 46aa67b47282d92147eff1ae08bb656a74194d54d27d58659fa4a93f30c7154c
+  data.tar.gz: 3ab87db22f0790870a7e4531fc67d0040fb151fbdecd4536463233373969e28f
+SHA512:
+  metadata.gz: b86910b42f6c353b1da62967303d449bcf34586013f882b07f59b58c154446c5e7dd21d24962a92efd211655f5eed66f7d029637ea203ca79c75b8ef4fc20247
+  data.tar.gz: ad810d49236687268290514e5ad51772a112f9da9928ec16c1647f997fc43d9f99fc58c8d0fab529f5e9ae711da3a0057b924a1ca94cd7b998515aa756d30cc6

data/lib/ask/channel_providers/adapter.rb

@@ -0,0 +1,107 @@
+# frozen_string_literal: true
+
+module Ask
+  module ChannelProviders
+    # Abstract base class for channel adapters.
+    #
+    # A channel adapter wraps a messaging platform (e.g., Telegram, Discord, Slack)
+    # and provides a uniform interface for the coder engine to communicate through it.
+    #
+    # Subclasses must implement all methods that raise NotImplementedError.
+    class Adapter
+      # Start the channel and begin receiving messages.
+      #
+      # The channel should call the provided block whenever a user message arrives.
+      # The block receives { chat_id:, user_id:, text:, session_key: }.
+      #
+      # @param config [Hash] channel-specific configuration
+      # @param on_message [Proc] callback for incoming messages
+      def start(config: {}, &on_message)
+        raise NotImplementedError, "#{self.class} must implement #start"
+      end
+
+      # Stop the channel gracefully.
+      def stop
+        raise NotImplementedError, "#{self.class} must implement #stop"
+      end
+
+      # Send a text message to a chat.
+      #
+      # @param chat_id [Integer, String] the chat/thread identifier
+      # @param text [String] the message text
+      # @return [void]
+      def send_message(chat_id, text)
+        raise NotImplementedError, "#{self.class} must implement #send_message"
+      end
+
+      # Edit a previously sent message (for streaming updates).
+      #
+      # @param chat_id [Integer, String] the chat/thread identifier
+      # @param message_id [Integer] the message ID to edit
+      # @param text [String] the new text
+      # @return [void]
+      def edit_message(chat_id, message_id, text)
+        raise NotImplementedError, "#{self.class} must implement #edit_message"
+      end
+
+      # Send an approval request with accept/decline buttons.
+      #
+      # @param chat_id [Integer, String] the chat/thread identifier
+      # @param tool_name [String] the name of the tool requesting permission
+      # @param risk_level [String] the risk level string
+      # @param details [String] human-readable details about the request
+      # @return [void]
+      def request_approval(chat_id, tool_name:, risk_level:, details:)
+        raise NotImplementedError, "#{self.class} must implement #request_approval"
+      end
+
+      # Send a rich card (cross-platform UI).
+      #
+      # Each adapter renders the Card to its native format.
+      # Default implementation falls back to markdown text.
+      #
+      # @param chat_id [Integer, String] the chat identifier
+      # @param card [Card] the card to render
+      def send_card(chat_id, card)
+        text = render_card_to_text(card)
+        send_message(chat_id, text) if text
+      end
+
+      # Render a card to plain text fallback.
+      # Override in platform adapters for rich rendering.
+      def render_card_to_text(card)
+        lines = []
+        card.sections.each do |section|
+          lines << "**#{section.title}**" unless section.title.empty?
+          section.components.each do |comp|
+            case comp
+            when Card::TextBlock
+              lines << comp.content
+            when Card::Table
+              lines << "| #{comp.header.join(' | ')} |"
+              lines << "| #{comp.header.map { '-' * _1.length }.join(' | ')} |"
+              comp.rows.each { |row| lines << "| #{row.join(' | ')} |" }
+            when Card::Divider
+              lines << "---"
+            end
+          end
+          lines << ""
+        end
+        lines.join("\n").strip
+      end
+
+      # Register a callback handler for interactive button presses.
+      # Called with { chat_id:, user_id:, data:, callback_query_id: }
+      def set_callback_handler(handler)
+        @callback_handler = handler
+      end
+
+      # Whether the channel connection is active.
+      #
+      # @return [Boolean]
+      def running?
+        false
+      end
+    end
+  end
+end

data/lib/ask/channel_providers/card.rb

@@ -0,0 +1,84 @@
+# frozen_string_literal: true
+
+module Ask
+  module ChannelProviders
+    # Cross-platform card system for rich message rendering.
+    #
+    # A Card is a structured UI element that each channel adapter renders
+    # into its native format:
+    #   Telegram  → Markdown text + inline keyboards
+    #   Discord   → Embeds + message components
+    #   Slack     → Block Kit
+    #
+    # @example
+    #   card = Ask::ChannelProviders::Card.new do |c|
+    #     c.section "Deploy Status"
+    #     c.text "Build **#42** passed"
+    #     c.button "View Logs", callback: "/logs 42"
+    #     c.table header: ["File", "Status"], rows: [["app.rb", "✅"]]
+    #   end
+    #   @channel.send_card(chat_id, card)
+    class Card
+      attr_reader :sections
+
+      def initialize
+        @sections = []
+        yield self if block_given?
+      end
+
+      # Add a section title.
+      def section(text)
+        @sections << Section.new(text)
+      end
+
+      # Add a text block to the last section.
+      def text(content, style: nil)
+        last_section << TextBlock.new(content: content, style: style)
+      end
+
+      # Add a button to the last section.
+      def button(label, callback: nil, url: nil)
+        last_section << Button.new(label: label, callback: callback, url: url)
+      end
+
+      # Add a table to the last section.
+      def table(header:, rows:)
+        last_section << Table.new(header: header, rows: rows)
+      end
+
+      # Add a divider line.
+      def divider
+        last_section << Divider.new
+      end
+
+      private
+
+      def last_section
+        @sections.last || (@sections << Section.new(""))[-1]
+      end
+
+      # ── Components ──────────────────────────────────────────────────────
+
+      Section = Struct.new(:title) do
+        attr_reader :components
+
+        def initialize(title)
+          super(title)
+          @components = []
+        end
+
+        def <<(component)
+          @components << component
+        end
+      end
+
+      TextBlock = Struct.new(:content, :style, keyword_init: true)
+
+      Button = Struct.new(:label, :callback, :url, keyword_init: true)
+
+      Table = Struct.new(:header, :rows, keyword_init: true)
+
+      Divider = Struct.new
+    end
+  end
+end

data/lib/ask/channel_providers/telegram/adapter.rb

@@ -0,0 +1,284 @@
+# frozen_string_literal: true
+
+module Ask
+  module ChannelProviders
+    module Telegram
+      # ChannelAdapter implementation for Telegram.
+      #
+      # Wraps Ask::ChannelProviders::Telegram::Bot into the Adapter interface,
+      # handling message dispatch, streaming edits, and approval requests.
+      class Adapter < Ask::ChannelProviders::Adapter
+        # @param token [String] Telegram bot token
+        # @param allowed_users [Array<Integer>] allowed user IDs (empty = all)
+        # @param allowed_chats [Array<Integer>] allowed group chat IDs (empty = all)
+        def initialize(token:, allowed_users: [], allowed_chats: [])
+          @token = token
+          @allowed_users = allowed_users
+          @allowed_chats = allowed_chats
+          @bot = nil
+          @bot_user_id = nil
+          @message_handler = nil
+          @callback_handler = nil
+          @pending_permissions = {}  # callback_data -> Queue for approval responses
+        end
+
+        def start(config: {}, &on_message)
+          @message_handler = on_message
+          @bot = Bot.new(token: @token)
+          @bot.start do |msg|
+            handle_incoming(msg)
+          end
+          @bot.on_callback = method(:handle_callback)
+          @bot_user_id = @bot.bot_user_id
+        end
+
+        def stop
+          @bot&.stop
+          @bot = nil
+        end
+
+        def running?
+          @bot&.running? || false
+        end
+
+        # Send a text message, returns the message ID.
+        def send_message(chat_id, text)
+          log("[response] #{text[0..80]}...")
+          response = try_send_markdown(chat_id, text)
+          response ||= @bot&.send_message(chat_id: chat_id, text: text)
+          response&.dig("result", "message_id")
+        rescue => e
+          nil
+        end
+
+        # Edit a previously sent message (streaming updates).
+        def edit_message(chat_id, message_id, text)
+          log("[response] edit #{message_id}: #{text[0..60]}...")
+          return unless @bot && message_id
+          try_edit_markdown(chat_id, message_id, text) ||
+            @bot.edit_message(chat_id: chat_id, message_id: message_id, text: text)
+        rescue => e
+          nil
+        end
+
+        # Handle inline keyboard button clicks.
+        def handle_callback(callback)
+          cq_id = callback[:callback_query_id]
+          data = callback[:data]
+          chat_id = callback[:chat_id]
+          user_id = callback[:user_id]
+
+          # Answer the callback (removes loading spinner on the button)
+          @bot&.answer_callback_query(callback_query_id: cq_id)
+
+          # Check if this is a permission approval callback
+          if data && data.include?(":allow")
+            callback_id = data.sub(":allow", "")
+            if (queue = @pending_permissions.delete(callback_id))
+              queue << "allow"
+              return
+            end
+          elsif data && data.include?(":deny")
+            callback_id = data.sub(":deny", "")
+            if (queue = @pending_permissions.delete(callback_id))
+              queue << "deny"
+              return
+            end
+          end
+
+          # Forward all other callbacks to the engine's callback handler
+          @callback_handler&.call(
+            chat_id: chat_id,
+            user_id: user_id,
+            data: data,
+            callback_query_id: cq_id
+          )
+        rescue => e
+          # Silently handle callback errors
+        end
+
+        private
+
+        def log(msg)
+          if defined?(Ask::Coder::Log)
+            Ask::Coder::Log.debug(msg) rescue nil
+          else
+            STDERR.puts "[adapter] #{msg}"
+          end
+        end
+
+        def try_send_markdown(chat_id, text)
+          # Escape underscores and brackets so session IDs and data don't break Markdown
+          safe = text.gsub("_", "\\_").gsub("[", "\\[")
+          @bot&.send_message(chat_id: chat_id, text: safe, parse_mode: "Markdown")
+        rescue
+          nil  # fall back to plain text
+        end
+
+        def try_edit_markdown(chat_id, message_id, text)
+          safe = text.gsub("_", "\\_").gsub("[", "\\[")
+          @bot&.edit_message(chat_id: chat_id, message_id: message_id, text: "⏳ #{safe}", parse_mode: "Markdown")
+        rescue
+          nil  # fall back to plain text
+        end
+
+        public
+
+        # Set a handler for non-permission callbacks (session switching, etc.)
+        def set_callback_handler(handler)
+          @callback_handler = handler
+        end
+
+        # Send a rich card rendered as markdown + inline keyboards.
+        def send_card(chat_id, card)
+          log("[send_card] #{card.sections.length} sections")
+          lines = []
+          buttons = []
+
+          card.sections.each do |section|
+            lines << "**#{section.title}**" unless section.title.empty?
+            section.components.each do |comp|
+              case comp
+              when Card::TextBlock
+                lines << comp.content
+              when Card::Button
+                if comp.callback
+                  buttons << [{ text: comp.label, callback_data: comp.callback }]
+                elsif comp.url
+                  lines << "[#{comp.label}](#{comp.url})"
+                end
+              when Card::Table
+                lines << "| #{comp.header.join(' | ')} |"
+                lines << "| #{comp.header.map { |h| '—' * h.length }.join(' | ')} |"
+                comp.rows.each { |row| lines << "| #{row.join(' | ')} |" }
+              when Card::Divider
+                lines << "───"
+              end
+            end
+            lines << ""
+          end
+
+          text = lines.join("\n").strip
+          return if text.empty?
+
+          log("[send_card] bot=#{!@bot.nil?} buttons=#{buttons.length} text=#{text.length}ch")
+          if buttons.any?
+            @bot&.send_keyboard_message(chat_id: chat_id, text: text, buttons: buttons)
+          else
+            @bot&.send_message(chat_id: chat_id, text: text, parse_mode: "Markdown")
+          end
+        rescue => e
+          log("[send_card] ERROR: #{e.message[0..80]}")
+          nil
+        end
+
+        # Send an approval request with inline buttons.
+        # Returns the approval Queue for the engine to wait on.
+        def request_approval(chat_id, tool_name:, risk_level:, details:)
+          risk_label = {
+            "low" => "Low Risk", "medium" => "Medium Risk",
+            "high" => "High Risk", "critical" => "Critical Risk"
+          }.fetch(risk_level, risk_level)
+
+          callback_id = "perm:#{chat_id}:#{Time.now.to_i}"
+          text = ["🔐 Approval Required",
+                  "Tool: #{tool_name} (#{risk_label})",
+                  details].join("\n")
+
+          buttons = [
+            [{ text: "✅ Approve", callback_data: "#{callback_id}:allow" },
+             { text: "❌ Deny", callback_data: "#{callback_id}:deny" }]
+          ]
+
+          queue = Queue.new
+          @pending_permissions[callback_id] = queue
+
+          @bot&.send_keyboard_message(
+            chat_id: chat_id, text: text, buttons: buttons
+          )
+
+          queue  # Engine waits on this queue for the decision
+        rescue => e
+          nil
+        end
+
+        private
+
+        def handle_incoming(msg)
+          return unless @message_handler
+          return if msg[:is_group] && !group_triggered?(msg)
+
+          chat_id = msg[:chat_id]
+          user_id = msg[:user_id]
+          text = msg[:text]
+          return unless allowed?(chat_id, user_id, msg[:is_group])
+          return if text.nil? || text.strip.empty?
+
+          # Handle built-in commands
+          case text.strip
+          when "/id", "/start", "/new", "/sessions", "/status", "/projects", "/mode", "/help", "/models", "/goal", "/sync"
+            handle_command(chat_id, user_id, text.strip)
+            return
+          end
+
+          @message_handler.call(
+            chat_id: chat_id,
+            user_id: user_id,
+            session_key: msg[:is_group] ? chat_id : user_id,
+            text: text.strip,
+            raw: msg
+          )
+        end
+
+        def handle_command(chat_id, user_id, command)
+          case command
+          when "/id"
+            @bot&.send_message(chat_id: chat_id, text: "Your Telegram user ID: `#{user_id}`")
+          when "/start"
+            @bot&.send_message(chat_id: chat_id, text: "🤖 Askoda bot active!\n\nSend /help to see all commands.\n/id - get your user ID\n/new - start fresh conversation")
+          when "/new", "/sessions", "/status", "/projects", "/mode", "/help", "/models", "/goal", "/sync"
+            @message_handler&.call(
+              chat_id: chat_id,
+              user_id: user_id,
+              session_key: chat_id < 0 ? chat_id : user_id,
+              text: command,
+              raw: nil
+            )
+          end
+        rescue => e
+          # Silently handle send errors during command responses
+        end
+
+        def allowed?(chat_id, user_id, is_group)
+          if is_group
+            @allowed_chats.empty? || @allowed_chats.include?(chat_id)
+          else
+            @allowed_users.empty? || @allowed_users.include?(user_id)
+          end
+        end
+
+        def group_triggered?(msg)
+          text = msg[:text] || ""
+          return false unless @bot_user_id
+
+          raw = msg[:raw]
+          return false unless raw.respond_to?(:reply_to_message) || raw.respond_to?(:entities)
+
+          replied = raw.respond_to?(:reply_to_message) ? raw.reply_to_message : nil
+          return true if replied && replied.respond_to?(:from) && replied.from.respond_to?(:id) &&
+                         replied.from.id == @bot_user_id
+
+          entities = raw.respond_to?(:entities) ? raw.entities : nil
+          return false unless entities.respond_to?(:any?)
+
+          entities.any? do |ent|
+            next false unless ent.respond_to?(:type) && ent.type == "mention"
+            next false unless ent.respond_to?(:offset) && ent.respond_to?(:length)
+            mention = text[ent.offset, ent.length]
+            mention && mention.downcase == "@#{@bot_user_id}".downcase
+          end
+        end
+      end
+    end
+  end
+end

data/lib/ask/channel_providers/telegram/bot.rb

@@ -0,0 +1,231 @@
+# frozen_string_literal: true
+
+require "telegram/bot"
+
+module Ask
+  module ChannelProviders
+    module Telegram
+      # Polling-based Telegram bot client.
+      #
+      # Receives messages via getUpdates polling and wraps the telegram-bot-ruby
+      # client with a simpler interface.
+      #
+      # @example
+      #   bot = Ask::ChannelProviders::Telegram::Bot.new(token: "123:ABC")
+      #   bot.on_message { |msg| puts msg[:text] }
+      #   bot.start
+      #   bot.send_message(chat_id: 123, text: "Hello")
+      #   bot.stop
+      class Bot
+        attr_reader :token, :bot_user_id
+        attr_accessor :on_callback
+
+        # @param token [String] Telegram bot token from @BotFather
+        MAX_DEDUP_CACHE = 500
+
+        def initialize(token:)
+          @token = token
+          @client = ::Telegram::Bot::Client.new(token)
+          @running = false
+          @on_message = nil
+          @on_callback = nil
+          @poll_thread = nil
+          @last_update_id = 0
+          @bot_user_id = nil
+          @processed_updates = []  # ring buffer of recent update_ids
+        end
+
+        # Start polling for messages.
+        #
+        # @param interval [Float] seconds between polls
+        # @param on_message [Proc] called with { chat_id:, user_id:, text:, date:, raw: }
+        # @param on_callback [Proc] called with { callback_query_id:, data:, chat_id:, user_id:, message_id: }
+        def start(interval: 1.0, &on_message)
+          @on_message = on_message
+          @running = true
+          fetch_bot_info
+          @poll_thread = Thread.new { poll_loop(interval) }
+        end
+
+        # Stop polling.
+        def stop
+          @running = false
+          @poll_thread&.join(5) rescue nil
+          @poll_thread = nil
+        end
+
+        def running?
+          @running
+        end
+
+        # Send a text message to a chat.
+        def log(msg)
+          if defined?(Ask::Coder::Log)
+            Ask::Coder::Log.debug(msg) rescue nil
+          elsif ENV["DEBUG"] == "1"
+            STDERR.puts "[bot] #{msg}"
+          end
+        end
+
+        def send_message(chat_id:, text:, parse_mode: nil)
+          log("[send] msg #{text.length}ch#{parse_mode ? " (#{parse_mode})" : ""}")
+          params = { chat_id: chat_id, text: text }
+          params[:parse_mode] = parse_mode if parse_mode
+          @client.api.send_message(params)
+          log("[send] ✅ delivered")
+        rescue ::Telegram::Bot::Exceptions::Base => e
+          log("[send] FAIL: #{e.message[0..80]}")
+          raise Ask::ChannelProviders::APIError, "Telegram API error: #{e.message}"
+        end
+
+        # Send a message with inline keyboard buttons.
+        def send_keyboard_message(chat_id:, text:, buttons:, parse_mode: nil)
+          n = buttons.flatten.length
+          log("[send] #{n} btn(s): #{buttons.flatten.map { |b| b[:text] }.inspect}")
+          keyboard_rows = buttons.map do |row|
+            row.map { |btn| ::Telegram::Bot::Types::InlineKeyboardButton.new(**btn) }
+          end
+          reply_markup = ::Telegram::Bot::Types::InlineKeyboardMarkup.new(inline_keyboard: keyboard_rows)
+          params = { chat_id: chat_id, text: text, reply_markup: reply_markup }
+          params[:parse_mode] = parse_mode if parse_mode
+          @client.api.send_message(params)
+          log("[send] ✅ delivered")
+        rescue ::Telegram::Bot::Exceptions::Base => e
+          log("[send] KEYBOARD FAIL: #{e.message[0..120]}")
+          # Fallback: send plain text without buttons
+          send_message(chat_id: chat_id, text: text)
+        end
+
+        # Answer a callback query (required by Telegram, removes the loading spinner).
+        def answer_callback_query(callback_query_id:, text: nil)
+          log("[send] callback answer")
+          params = { callback_query_id: callback_query_id }
+          params[:text] = text if text
+          @client.api.answer_callback_query(params)
+        rescue ::Telegram::Bot::Exceptions::Base
+          # Silently ignore errors
+        end
+
+        # Edit a message (for streaming updates).
+        def edit_message(chat_id:, message_id:, text:, parse_mode: nil)
+          log("[send] edit msg #{message_id} #{text.length}ch")
+          params = { chat_id: chat_id, message_id: message_id, text: text }
+          params[:parse_mode] = parse_mode if parse_mode
+          @client.api.edit_message_text(params)
+        rescue ::Telegram::Bot::Exceptions::Base => e
+          desc = e.respond_to?(:data) ? (e.data[:description] || e.data["description"] || e.message) : e.message
+          raise Ask::ChannelProviders::APIError, e.message unless desc.include?("message is not modified")
+        end
+
+        # Delete a message.
+        def delete_message(chat_id:, message_id:)
+          @client.api.delete_message(chat_id: chat_id, message_id: message_id)
+        rescue ::Telegram::Bot::Exceptions::Base
+          # Silently ignore if already deleted
+        end
+
+        # Get bot info.
+        def me
+          @me ||= @client.api.get_me
+        rescue ::Telegram::Bot::Exceptions::Base => e
+          raise Ask::ChannelProviders::APIError, "Failed to get bot info: #{e.message}"
+        end
+
+        private
+
+        def fetch_bot_info
+          info = me
+          @bot_user_id = info.id if info
+        rescue => e
+          # Bot info unavailable (e.g., test tokens), continue without it
+        end
+
+        def poll_loop(interval)
+          while @running
+            begin
+              fetch_updates
+            rescue => e
+              # Log error, continue polling
+            end
+            sleep(interval)
+          end
+        end
+
+        def fetch_updates
+          params = { offset: @last_update_id + 1, timeout: 5 }
+          updates = @client.api.get_updates(params)
+          updates = Array(updates)
+          updates.each do |update|
+            process_update(update)
+            uid = update.respond_to?(:update_id) ? update.update_id : nil
+            @last_update_id = uid if uid && uid >= @last_update_id
+          end
+        rescue ::Telegram::Bot::Exceptions::Base => e
+          raise Ask::ChannelProviders::APIError, "Polling error: #{e.message}"
+        end
+
+        def process_update(update)
+          # Dedup: skip already-processed update_ids
+          uid = update.respond_to?(:update_id) ? update.update_id : nil
+          if uid && @processed_updates.include?(uid)
+            return
+          end
+          @processed_updates << uid if uid
+          @processed_updates.shift if @processed_updates.length > MAX_DEDUP_CACHE
+
+          # Handle callback queries (inline keyboard button clicks)
+          if update.respond_to?(:callback_query) && update.callback_query
+            handle_callback_query(update.callback_query)
+            return
+          end
+
+          message = extract_message(update)
+          return unless message
+
+          chat = message.respond_to?(:chat) ? message.chat : nil
+          from = message.respond_to?(:from) ? message.from : nil
+          text = message.respond_to?(:text) ? message.text : nil
+          return unless chat && text
+
+          chat_type = chat.respond_to?(:type) ? chat.type.to_s : ""
+
+          msg = {
+            chat_id: chat.respond_to?(:id) ? chat.id : nil,
+            user_id: from.respond_to?(:id) ? from.id : nil,
+            text: text,
+            date: message.respond_to?(:date) ? message.date : nil,
+            is_group: %w[group supergroup].include?(chat_type),
+            message_id: message.respond_to?(:message_id) ? message.message_id : nil,
+            raw: message
+          }
+
+          @on_message&.call(msg)
+        end
+
+        def handle_callback_query(cq)
+          return unless @on_callback
+          data = cq.respond_to?(:data) ? cq.data : nil
+          msg = cq.respond_to?(:message) ? cq.message : nil
+          from = cq.respond_to?(:from) ? cq.from : nil
+          return unless data && msg && from
+
+          @on_callback.call(
+            callback_query_id: cq.respond_to?(:id) ? cq.id : nil,
+            data: data,
+            chat_id: msg.respond_to?(:chat) && msg.chat.respond_to?(:id) ? msg.chat.id : nil,
+            user_id: from.respond_to?(:id) ? from.id : nil,
+            message_id: msg.respond_to?(:message_id) ? msg.message_id : nil,
+            raw: cq
+          )
+        end
+
+        def extract_message(update)
+          m = update.respond_to?(:message) ? update.message : nil
+          m ||= update.respond_to?(:channel_post) ? update.channel_post : nil
+          m ||= update.respond_to?(:edited_message) ? update.edited_message : nil
+          m
+        end
+      end
+    end
+  end
+end

data/lib/ask/channel_providers/telegram.rb

@@ -0,0 +1,15 @@
+# frozen_string_literal: true
+
+require_relative "telegram/bot"
+require_relative "telegram/adapter"
+
+module Ask
+  module ChannelProviders
+    # Telegram channel provider for the ask-coder ecosystem.
+    #
+    # Provides a polling-based Telegram bot client and a ChannelAdapter
+    # implementation that plugs into Ask::Coder.
+    module Telegram
+    end
+  end
+end

data/lib/ask/channel_providers/version.rb

@@ -0,0 +1,7 @@
+# frozen_string_literal: true
+
+module Ask
+  module ChannelProviders
+    VERSION = "0.1.0"
+  end
+end

data/lib/ask/channel_providers.rb

@@ -0,0 +1,14 @@
+# frozen_string_literal: true
+
+require_relative "channel_providers/version"
+require_relative "channel_providers/card"
+require_relative "channel_providers/adapter"
+require_relative "channel_providers/telegram"
+
+module Ask
+  module ChannelProviders
+    class Error < StandardError; end
+    class ConfigurationError < Error; end
+    class APIError < Error; end
+  end
+end

data/lib/ask-channel-providers.rb

@@ -0,0 +1,3 @@
+# frozen_string_literal: true
+
+require_relative "ask/channel_providers"

metadata

@@ -0,0 +1,121 @@
+--- !ruby/object:Gem::Specification
+name: ask-channel-providers
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+platform: ruby
+authors:
+- Kaka Ruto
+bindir: bin
+cert_chain: []
+date: 1980-01-02 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: telegram-bot-ruby
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2.0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2.0'
+- !ruby/object:Gem::Dependency
+  name: minitest
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '5.25'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '5.25'
+- !ruby/object:Gem::Dependency
+  name: mocha
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.1'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.1'
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '13.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '13.0'
+- !ruby/object:Gem::Dependency
+  name: simplecov
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.22'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.22'
+description: Channel adapter interface and implementations (Telegram, Discord, Slack)
+  for connecting AI coding agents to messaging platforms.
+email:
+- kaka@myrrlabs.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- lib/ask-channel-providers.rb
+- lib/ask/channel_providers.rb
+- lib/ask/channel_providers/adapter.rb
+- lib/ask/channel_providers/card.rb
+- lib/ask/channel_providers/telegram.rb
+- lib/ask/channel_providers/telegram/adapter.rb
+- lib/ask/channel_providers/telegram/bot.rb
+- lib/ask/channel_providers/version.rb
+homepage: https://github.com/ask-rb/ask-channel-providers
+licenses:
+- MIT
+metadata:
+  homepage_uri: https://github.com/ask-rb/ask-channel-providers
+  source_code_uri: https://github.com/ask-rb/ask-channel-providers
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '3.2'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 4.0.3
+specification_version: 4
+summary: Messaging channel adapters for the ask-rb ecosystem
+test_files: []