pocketrb 0.1.0

data/lib/pocketrb/channels/whatsapp.rb

@@ -0,0 +1,242 @@
+# frozen_string_literal: true
+
+require "json"
+require "socket"
+
+module Pocketrb
+  module Channels
+    # WhatsApp channel via Node.js bridge WebSocket
+    # Connects to a whatsapp-web.js bridge running on localhost
+    #
+    # Bridge Protocol:
+    # - Receive: {type: "message", sender: "...", content: "...", timestamp: ..., isGroup: bool}
+    # - Send: {type: "send", to: "phone@s.whatsapp.net", text: "..."}
+    # - Status: {type: "status", status: "connected"}
+    # - QR: {type: "qr", qr: "data:image/png;base64,..."}
+    class WhatsApp < Base
+      RECONNECT_DELAY = 5
+      DEFAULT_BRIDGE_URL = "ws://localhost:3001"
+
+      def initialize(bus:, bridge_url: DEFAULT_BRIDGE_URL, allowed_users: nil, download_media: true)
+        super(bus: bus, name: :whatsapp)
+        @bridge_url = bridge_url
+        @allowed_users = allowed_users # Array of phone numbers
+        @download_media = download_media
+        @ws = nil
+        @connected = false
+        @media_processor = Media::Processor.new
+      end
+
+      # Check if we can connect to the bridge
+      def available?
+        require "websocket-client-simple"
+        true
+      rescue LoadError
+        false
+      end
+
+      protected
+
+      def run_inbound_loop
+        require "websocket-client-simple"
+
+        Pocketrb.logger.info("Starting WhatsApp channel (bridge: #{@bridge_url})")
+
+        loop do
+          break unless @running
+
+          begin
+            connect_and_listen
+          rescue StandardError => e
+            Pocketrb.logger.error("WhatsApp connection error: #{e.message}")
+          end
+
+          if @running
+            Pocketrb.logger.info("Reconnecting to WhatsApp bridge in #{RECONNECT_DELAY}s...")
+            sleep RECONNECT_DELAY
+          end
+        end
+      rescue LoadError
+        Pocketrb.logger.error("websocket-client-simple gem not installed. Run: gem install websocket-client-simple")
+        raise
+      end
+
+      def send_message(message)
+        return unless @ws && @connected
+
+        jid = to_jid(message.chat_id)
+        payload = {
+          type: "send",
+          to: jid,
+          text: message.content
+        }
+
+        @ws.send(payload.to_json)
+        Pocketrb.logger.debug("WhatsApp: sent message to #{jid}")
+      rescue StandardError => e
+        Pocketrb.logger.error("WhatsApp send error: #{e.message}")
+      end
+
+      private
+
+      def connect_and_listen
+        channel = self
+
+        @ws = WebSocket::Client::Simple.connect(@bridge_url)
+
+        @ws.on :open do
+          channel.instance_variable_set(:@connected, true)
+          Pocketrb.logger.info("WhatsApp: connected to bridge")
+        end
+
+        @ws.on :message do |msg|
+          channel.send(:handle_bridge_message, msg.data)
+        end
+
+        @ws.on :error do |e|
+          Pocketrb.logger.error("WhatsApp WebSocket error: #{e.message}")
+        end
+
+        @ws.on :close do |_e|
+          channel.instance_variable_set(:@connected, false)
+          Pocketrb.logger.warn("WhatsApp: disconnected from bridge")
+        end
+
+        # Block until disconnected
+        sleep 0.5 while @ws.open? && @running
+      end
+
+      def handle_bridge_message(data)
+        message = JSON.parse(data)
+
+        case message["type"]
+        when "message"
+          handle_incoming_message(message)
+        when "status"
+          Pocketrb.logger.info("WhatsApp status: #{message["status"]}")
+        when "qr"
+          handle_qr(message)
+        when "ready"
+          Pocketrb.logger.info("WhatsApp: ready")
+        when "authenticated"
+          Pocketrb.logger.info("WhatsApp: authenticated")
+        when "error"
+          Pocketrb.logger.error("WhatsApp error: #{message["error"]}")
+        else
+          Pocketrb.logger.debug("WhatsApp: unknown message type: #{message["type"]}")
+        end
+      rescue JSON::ParserError => e
+        Pocketrb.logger.warn("WhatsApp: invalid JSON: #{e.message}")
+      end
+
+      def handle_incoming_message(message)
+        sender = extract_phone(message["sender"] || message["from"])
+        return unless allowed_user?(sender)
+
+        # Skip if it's from self
+        return if message["fromMe"]
+
+        content = message["content"] || message["body"] || ""
+        chat_id = message["sender"] || message["from"]
+        is_group = message["isGroup"] || chat_id.include?("@g.us")
+
+        # Process media if present
+        media = []
+        if @download_media && message["hasMedia"]
+          media_item = process_whatsapp_media(message)
+          media << media_item if media_item
+
+          # Add indicator to content
+          content = "[Image attached - I can see this image]\n#{content}".strip if media_item&.image?
+          content = "[Media attached: #{media_item&.filename}]\n#{content}".strip if media_item && !media_item.image?
+        end
+
+        # Skip if no content and no media
+        return if content.empty? && media.empty?
+
+        Pocketrb.logger.debug("WhatsApp message from #{sender}: #{content[0..50]}... (#{media.size} media)")
+
+        inbound = create_inbound_message(
+          sender_id: sender,
+          chat_id: chat_id,
+          content: content.empty? ? "[media only]" : content,
+          media: media,
+          metadata: {
+            is_group: is_group,
+            timestamp: message["timestamp"],
+            message_id: message["id"]
+          }
+        )
+
+        @bus.publish_inbound(inbound)
+      end
+
+      def process_whatsapp_media(message)
+        return nil unless message["mediaData"] || message["mediaUrl"]
+
+        mime_type = message["mimetype"] || message["mediaType"] || "application/octet-stream"
+        filename = message["filename"] || "media_#{Time.now.to_i}.#{extension_for_mime(mime_type)}"
+
+        if message["mediaData"]
+          # Base64 encoded data from bridge
+          require "base64"
+          bytes = Base64.decode64(message["mediaData"])
+          @media_processor.from_bytes(bytes, mime_type: mime_type, filename: filename)
+        elsif message["mediaUrl"]
+          # URL to download
+          @media_processor.download(message["mediaUrl"], filename: filename, mime_type: mime_type)
+        end
+      rescue StandardError => e
+        Pocketrb.logger.warn("Failed to process WhatsApp media: #{e.message}")
+        nil
+      end
+
+      def extension_for_mime(mime_type)
+        case mime_type
+        when %r{^image/jpeg} then "jpg"
+        when %r{^image/png} then "png"
+        when %r{^image/gif} then "gif"
+        when %r{^image/webp} then "webp"
+        when %r{^audio/ogg} then "ogg"
+        when %r{^audio/mpeg} then "mp3"
+        when %r{^video/mp4} then "mp4"
+        else "bin"
+        end
+      end
+
+      def handle_qr(message)
+        return unless message["qr"]
+
+        Pocketrb.logger.info("WhatsApp: QR code received. Scan in bridge terminal or use the data URL.")
+        # Could save to file or display in terminal if needed
+      end
+
+      def allowed_user?(phone)
+        return true if @allowed_users.nil? || @allowed_users.empty?
+
+        normalized = normalize_phone(phone)
+        @allowed_users.any? { |allowed| normalize_phone(allowed) == normalized }
+      end
+
+      def to_jid(phone)
+        return phone if phone.include?("@")
+
+        # Remove any non-digits
+        clean = phone.gsub(/\D/, "")
+        "#{clean}@s.whatsapp.net"
+      end
+
+      def extract_phone(jid)
+        return jid unless jid
+
+        jid.split("@").first
+      end
+
+      def normalize_phone(phone)
+        return nil unless phone
+
+        phone.to_s.gsub(/\D/, "")
+      end
+    end
+  end
+end

data/lib/pocketrb/cli/base.rb

@@ -0,0 +1,119 @@
+# frozen_string_literal: true
+
+require "thor"
+
+module Pocketrb
+  class CLI
+    # Base class for CLI commands with common utilities
+    class Base < Thor
+      include Thor::Actions
+
+      # Configures Thor to exit with error status on command failure
+      # @return [Boolean] true to exit on failure
+      def self.exit_on_failure?
+        true
+      end
+
+      private
+
+      # Set up logging based on verbose/quiet options
+      def setup_logging
+        if options[:verbose]
+          Pocketrb.logger.level = Logger::DEBUG
+        elsif options[:quiet]
+          Pocketrb.logger.level = Logger::ERROR
+        end
+      end
+
+      # Resolve workspace directory from options or current directory
+      # @return [Pathname] workspace path
+      def resolve_workspace
+        path = options[:workspace] || Dir.pwd
+        Pathname.new(path).expand_path
+      end
+
+      # Resolve memory directory from options or workspace
+      # @return [Pathname] memory directory path
+      def resolve_memory_dir
+        path = options[:memory_dir] || options[:workspace] || Dir.pwd
+        Pathname.new(path).expand_path
+      end
+
+      # Create provider instance from config
+      # @param config [Config] configuration object
+      # @return [Providers::Base] provider instance
+      def create_provider(config)
+        provider_name = config[:provider]&.to_sym || :anthropic
+        Providers::Registry.get(provider_name, config.provider_config)
+      end
+
+      # Handle cron job execution
+      # @param agent_loop [Agent::Loop] agent loop instance
+      # @param bus [Bus::MessageBus] message bus
+      # @param job [Cron::Job] cron job to execute
+      def handle_cron_job(agent_loop, bus, job)
+        if job.payload.deliver
+          # Deliver message directly to channel
+          outbound = Pocketrb::Bus::OutboundMessage.new(
+            channel: job.payload.channel&.to_sym || :cli,
+            chat_id: job.payload.to || "cron",
+            content: job.payload.message
+          )
+          bus.publish_outbound(outbound)
+        else
+          # Process as agent task
+          msg = Pocketrb::Bus::InboundMessage.new(
+            channel: :cron,
+            sender_id: "cron",
+            chat_id: job.id,
+            content: job.payload.message,
+            metadata: { job_id: job.id, job_name: job.name }
+          )
+          agent_loop.process_message(msg)
+        end
+      end
+
+      # Process heartbeat message
+      # @param agent_loop [Agent::Loop] agent loop instance
+      # @param prompt [String] heartbeat prompt
+      # @return [String, nil] response content
+      def process_heartbeat(agent_loop, prompt)
+        msg = Pocketrb::Bus::InboundMessage.new(
+          channel: :heartbeat,
+          sender_id: "heartbeat",
+          chat_id: "heartbeat",
+          content: prompt
+        )
+        response = agent_loop.process_message(msg)
+        response&.content
+      end
+
+      # Default TOOLS.md content for new workspaces
+      # @return [String] markdown content
+      def default_tools_content
+        <<~MD
+          # Tools
+
+          This document describes the tools and skills available in this workspace.
+
+          ## Built-in Tools
+
+          - **read_file**: Read file contents
+          - **write_file**: Write content to a file
+          - **edit_file**: Edit a file with search/replace
+          - **list_dir**: List directory contents
+          - **exec**: Execute shell commands
+          - **web_search**: Search the web
+          - **web_fetch**: Fetch web page content
+          - **think**: Internal reasoning tool
+          - **plan**: Create and manage execution plans
+          - **memory**: Search and store in long-term memory
+
+          ## Skills
+
+          Create custom skills in the `skills/` directory.
+        MD
+      end
+    end
+  end
+end

data/lib/pocketrb/cli/chat.rb

@@ -0,0 +1,67 @@
+# frozen_string_literal: true
+
+module Pocketrb
+  class CLI
+    # Chat command - interactive chat mode
+    class Chat < Base
+      desc "chat", "Interactive chat mode (single session)"
+      option :model, type: :string, aliases: "-m", desc: "Model to use"
+      option :provider, type: :string, aliases: "-p", desc: "LLM provider"
+      option :system_prompt, type: :string, aliases: "-s", desc: "Custom system prompt"
+
+      # Starts an interactive chat session with the agent
+      # @return [void]
+      def call
+        setup_logging
+        workspace = resolve_workspace
+        memory_dir = resolve_memory_dir
+
+        config = Pocketrb::Config.load(memory_dir)
+        config[:model] = options[:model] if options[:model]
+        config[:provider] = options[:provider] if options[:provider]
+
+        provider = create_provider(config)
+        bus = Pocketrb::Bus::MessageBus.new
+
+        agent_loop = Pocketrb::Agent::Loop.new(
+          bus: bus,
+          provider: provider,
+          workspace: workspace,
+          memory_dir: memory_dir,
+          model: config[:model],
+          system_prompt: options[:system_prompt],
+          mcp_endpoint: config[:mcp_endpoint]
+        )
+
+        say "Pocketrb Chat - #{config[:model]}", :green
+        say "Memory: #{memory_dir}" if memory_dir != workspace
+        say "Type 'exit' or 'quit' to end session\n"
+
+        Async do
+          # Simple REPL
+          loop do
+            print "\n> "
+            input = $stdin.gets&.chomp
+            break if input.nil? || %w[exit quit].include?(input.downcase)
+
+            next if input.empty?
+
+            msg = Pocketrb::Bus::InboundMessage.new(
+              channel: :cli,
+              sender_id: "user",
+              chat_id: "chat",
+              content: input
+            )
+
+            response = agent_loop.process_message(msg)
+            puts "\n#{response.content}" if response
+          end
+        end
+
+        say "\nGoodbye!", :yellow
+      end
+
+      default_task :call
+    end
+  end
+end

data/lib/pocketrb/cli/config.rb

@@ -0,0 +1,52 @@
+# frozen_string_literal: true
+
+module Pocketrb
+  class CLI
+    # Config command - manages configuration
+    class Config < Thor
+      desc "show", "Show current configuration"
+      def show
+        workspace = options[:workspace] || Dir.pwd
+        config = Pocketrb::Config.load(workspace)
+
+        say "Configuration for #{workspace}:"
+        config.to_h.each do |key, value|
+          # Don't show API keys
+          display_value = key.to_s.include?("api_key") ? "[REDACTED]" : value
+          say "  #{key}: #{display_value}"
+        end
+      end
+
+      desc "set KEY VALUE", "Set a configuration value"
+      def set(key, value)
+        workspace = options[:workspace] || Dir.pwd
+        config = Pocketrb::Config.load(workspace)
+
+        # Type conversion
+        value = case value
+                when /^\d+$/ then value.to_i
+                when /^\d+\.\d+$/ then value.to_f
+                when "true" then true
+                when "false" then false
+                else value
+                end
+
+        config.set(key, value)
+        say "Set #{key} = #{value}", :green
+      end
+
+      desc "get KEY", "Get a configuration value"
+      def get(key)
+        workspace = options[:workspace] || Dir.pwd
+        config = Pocketrb::Config.load(workspace)
+
+        value = config[key]
+        if value
+          say "#{key}: #{value}"
+        else
+          say "Key '#{key}' not found", :yellow
+        end
+      end
+    end
+  end
+end

data/lib/pocketrb/cli/cron.rb

@@ -0,0 +1,144 @@
+# frozen_string_literal: true
+
+module Pocketrb
+  class CLI
+    # Cron command - manages scheduled jobs
+    class Cron < Thor
+      desc "list", "List scheduled jobs"
+      option :all, type: :boolean, aliases: "-a", desc: "Include disabled jobs"
+      def list
+        workspace = Pathname.new(options[:workspace] || Dir.pwd).expand_path
+        cron_store = workspace.join(".pocketrb", "data", "cron", "jobs.json")
+
+        service = Pocketrb::Cron::Service.new(
+          store_path: cron_store,
+          on_job: ->(_) {}
+        )
+
+        jobs = service.list_jobs(include_disabled: options[:all])
+        if jobs.empty?
+          say "No scheduled jobs", :yellow
+          return
+        end
+
+        say "Scheduled jobs:"
+        jobs.each do |job|
+          status = job.enabled ? "enabled" : "disabled"
+          next_run = job.state.next_run_at_ms ? Time.at(job.state.next_run_at_ms / 1000).strftime("%Y-%m-%d %H:%M") : "never"
+          say "  #{job.id}: #{job.name} [#{status}] - next: #{next_run}"
+        end
+      end
+
+      desc "add", "Add a scheduled job"
+      option :name, type: :string, required: true, desc: "Job name"
+      option :message, type: :string, required: true, desc: "Message to process"
+      option :every, type: :numeric, desc: "Run every N seconds"
+      option :cron, type: :string, desc: "Cron expression (e.g., '0 9 * * *')"
+      option :at, type: :string, desc: "Run once at ISO datetime"
+      option :deliver, type: :boolean, default: false, desc: "Deliver to channel instead of processing"
+      option :channel, type: :string, desc: "Target channel for delivery"
+      option :to, type: :string, desc: "Target chat ID for delivery"
+      def add
+        workspace = Pathname.new(options[:workspace] || Dir.pwd).expand_path
+        cron_store = workspace.join(".pocketrb", "data", "cron", "jobs.json")
+
+        service = Pocketrb::Cron::Service.new(
+          store_path: cron_store,
+          on_job: ->(_) {}
+        )
+
+        job = if options[:every]
+                service.add_interval_job(
+                  name: options[:name],
+                  every: options[:every],
+                  message: options[:message],
+                  deliver: options[:deliver],
+                  channel: options[:channel],
+                  to: options[:to]
+                )
+              elsif options[:cron]
+                service.add_cron_job(
+                  name: options[:name],
+                  cron: options[:cron],
+                  message: options[:message],
+                  deliver: options[:deliver],
+                  channel: options[:channel],
+                  to: options[:to]
+                )
+              elsif options[:at]
+                at_time = Time.parse(options[:at])
+                service.add_one_time_job(
+                  name: options[:name],
+                  at: at_time,
+                  message: options[:message],
+                  deliver: options[:deliver],
+                  channel: options[:channel],
+                  to: options[:to]
+                )
+              else
+                say "Error: Must specify --every, --cron, or --at", :red
+                exit 1
+              end
+
+        say "Created job: #{job.id} (#{job.name})", :green
+      end
+
+      desc "remove JOB_ID", "Remove a scheduled job"
+      def remove(job_id)
+        workspace = Pathname.new(options[:workspace] || Dir.pwd).expand_path
+        cron_store = workspace.join(".pocketrb", "data", "cron", "jobs.json")
+
+        service = Pocketrb::Cron::Service.new(
+          store_path: cron_store,
+          on_job: ->(_) {}
+        )
+
+        if service.remove_job(job_id)
+          say "Removed job: #{job_id}", :green
+        else
+          say "Job not found: #{job_id}", :red
+        end
+      end
+
+      desc "enable JOB_ID", "Enable a scheduled job"
+      def enable(job_id)
+        workspace = Pathname.new(options[:workspace] || Dir.pwd).expand_path
+        cron_store = workspace.join(".pocketrb", "data", "cron", "jobs.json")
+
+        service = Pocketrb::Cron::Service.new(
+          store_path: cron_store,
+          on_job: ->(_) {}
+        )
+
+        if service.enable_job(job_id, enabled: true)
+          say "Enabled job: #{job_id}", :green
+        else
+          say "Job not found: #{job_id}", :red
+        end
+      end
+
+      desc "disable JOB_ID", "Disable a scheduled job"
+      def disable(job_id)
+        workspace = Pathname.new(options[:workspace] || Dir.pwd).expand_path
+        cron_store = workspace.join(".pocketrb", "data", "cron", "jobs.json")
+
+        service = Pocketrb::Cron::Service.new(
+          store_path: cron_store,
+          on_job: ->(_) {}
+        )
+
+        if service.enable_job(job_id, enabled: false)
+          say "Disabled job: #{job_id}", :green
+        else
+          say "Job not found: #{job_id}", :red
+        end
+      end
+
+      desc "trigger JOB_ID", "Trigger a job manually"
+      def trigger(_job_id)
+        say "Manual job execution requires running gateway", :yellow
+        say "Use 'pocketrb gateway' and the job will be executed", :yellow
+      end
+    end
+  end
+end