pocketrb 0.1.0

data/lib/pocketrb/cli/gateway.rb

@@ -0,0 +1,132 @@
+# frozen_string_literal: true
+
+module Pocketrb
+  class CLI
+    # Gateway command - starts all services together
+    class Gateway < Base
+      desc "gateway", "Start the gateway with all services"
+      option :model, type: :string, aliases: "-m", desc: "Model to use"
+      option :provider, type: :string, aliases: "-p", desc: "LLM provider"
+      option :telegram_token, type: :string, desc: "Telegram bot token"
+      option :telegram_users, type: :array, desc: "Allowed Telegram users"
+      option :whatsapp_bridge, type: :string, default: "ws://localhost:3001", desc: "WhatsApp bridge URL"
+      option :whatsapp_users, type: :array, desc: "Allowed WhatsApp numbers"
+      option :heartbeat_interval, type: :numeric, default: 1800, desc: "Heartbeat interval in seconds"
+      option :enable_cron, type: :boolean, default: true, desc: "Enable cron service"
+      option :enable_heartbeat, type: :boolean, default: true, desc: "Enable heartbeat service"
+      option :autonomous, type: :boolean, default: false, desc: "Skip permission prompts (for sandboxed environments)"
+
+      # Starts the gateway with all configured services (Telegram, WhatsApp, cron, heartbeat)
+      # @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]
+        config[:autonomous] = options[:autonomous] if options[:autonomous]
+
+        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],
+          max_iterations: config[:max_iterations]
+        )
+
+        say "Starting Pocketrb Gateway", :green
+        say "Provider: #{config[:provider]}/#{config[:model]}"
+        say "Workspace: #{workspace}"
+        say "Memory: #{memory_dir}" if memory_dir != workspace
+
+        channels = []
+        services = []
+        cron_service = nil
+
+        # Start Telegram if token provided
+        telegram_token = options[:telegram_token] || ENV.fetch("TELEGRAM_BOT_TOKEN", nil)
+        if telegram_token
+          channels << Pocketrb::Channels::Telegram.new(
+            bus: bus,
+            token: telegram_token,
+            allowed_users: options[:telegram_users]
+          )
+          say "  - Telegram: enabled"
+        end
+
+        # Start WhatsApp if bridge available
+        if options[:whatsapp_bridge]
+          channels << Pocketrb::Channels::WhatsApp.new(
+            bus: bus,
+            bridge_url: options[:whatsapp_bridge],
+            allowed_users: options[:whatsapp_users]
+          )
+          say "  - WhatsApp: enabled (#{options[:whatsapp_bridge]})"
+        end
+
+        # Start Cron service
+        if options[:enable_cron]
+          cron_store = memory_dir.join(".pocketrb", "data", "cron", "jobs.json")
+          cron_service = Pocketrb::Cron::Service.new(
+            store_path: cron_store,
+            on_job: ->(job) { handle_cron_job(agent_loop, bus, job) }
+          )
+          services << cron_service
+          # Pass cron_service to tools so agent can manage jobs
+          agent_loop.tools.update_context(cron_service: cron_service)
+          say "  - Cron: enabled"
+        end
+
+        # Start Heartbeat service
+        if options[:enable_heartbeat]
+          heartbeat_service = Pocketrb::Heartbeat::Service.new(
+            workspace: workspace,
+            interval: options[:heartbeat_interval],
+            on_heartbeat: ->(prompt) { process_heartbeat(agent_loop, prompt) }
+          )
+          services << heartbeat_service
+          say "  - Heartbeat: enabled (#{options[:heartbeat_interval]}s)"
+        end
+
+        # Set up status context for /status command on Telegram channels
+        status_context = {
+          provider: provider,
+          model: config[:model],
+          sessions: agent_loop.sessions,
+          memory_dir: memory_dir,
+          cron_service: cron_service
+        }
+        channels.each do |ch|
+          ch.status_context = status_context if ch.respond_to?(:status_context=)
+        end
+
+        say "\nPress Ctrl+C to stop\n"
+
+        Async do
+          # Start agent loop
+          agent_loop.run
+
+          # Start all channels
+          channels.each(&:run)
+
+          # Start all services
+          services.each(&:start)
+
+          # Keep running
+          sleep
+        end
+      rescue Interrupt
+        say "\nShutting down gateway...", :yellow
+        services.each(&:stop)
+      end
+
+      default_task :call
+    end
+  end
+end

data/lib/pocketrb/cli/init.rb

@@ -0,0 +1,39 @@
+# frozen_string_literal: true
+
+module Pocketrb
+  class CLI
+    # Init command - initializes a new Pocketrb workspace
+    class Init < Base
+      desc "init", "Initialize a new Pocketrb workspace"
+      # Initializes a new Pocketrb workspace with config and default structure
+      # @return [void]
+      def call
+        workspace = resolve_workspace
+        config_dir = workspace.join(".pocketrb")
+
+        if config_dir.exist?
+          say "Workspace already initialized at #{workspace}", :yellow
+          return
+        end
+
+        FileUtils.mkdir_p(config_dir)
+        FileUtils.mkdir_p(workspace.join("skills"))
+
+        Pocketrb::Config.new(workspace: workspace).save!
+
+        # Create default TOOLS.md
+        tools_file = workspace.join("TOOLS.md")
+        File.write(tools_file, default_tools_content) unless tools_file.exist?
+
+        say "Initialized Pocketrb workspace at #{workspace}", :green
+        say "  - Created .pocketrb/config.yml"
+        say "  - Created skills/"
+        say "\nNext steps:"
+        say "  1. Set your API key: export ANTHROPIC_API_KEY=your-key"
+        say "  2. Start chatting: pocketrb chat"
+      end
+
+      default_task :call
+    end
+  end
+end

data/lib/pocketrb/cli/plans.rb

@@ -0,0 +1,28 @@
+# frozen_string_literal: true
+
+module Pocketrb
+  class CLI
+    # Plans command - lists active execution plans
+    class Plans < Base
+      desc "plans", "List active plans"
+      # Lists all active execution plans in the workspace
+      # @return [void]
+      def call
+        workspace = resolve_workspace
+        manager = Pocketrb::Planning::Manager.new(workspace: workspace)
+
+        plans = manager.list_plans
+        if plans.empty?
+          say "No plans found", :yellow
+          return
+        end
+
+        plans.each do |plan|
+          say "\n#{plan.to_markdown}"
+        end
+      end
+
+      default_task :call
+    end
+  end
+end

data/lib/pocketrb/cli/skills.rb

@@ -0,0 +1,34 @@
+# frozen_string_literal: true
+
+module Pocketrb
+  class CLI
+    # Skills command - lists available skills from workspace
+    class Skills < Base
+      desc "skills", "List available skills"
+      # Lists all available skills from the workspace skills directory
+      # @return [void]
+      def call
+        workspace = resolve_workspace
+        loader = Pocketrb::Skills::Loader.new(workspace: workspace)
+
+        skills = loader.list_skills
+        if skills.empty?
+          say "No skills found in #{workspace}/skills/", :yellow
+          return
+        end
+
+        say "Available skills:"
+        skills.each do |skill|
+          flags = []
+          flags << "always" if skill.always?
+          flags << "triggers: #{skill.triggers.join(", ")}" if skill.triggers.any?
+
+          flag_str = flags.any? ? " (#{flags.join(", ")})" : ""
+          say "  - #{skill.name}: #{skill.description}#{flag_str}"
+        end
+      end
+
+      default_task :call
+    end
+  end
+end

data/lib/pocketrb/cli/start.rb

@@ -0,0 +1,55 @@
+# frozen_string_literal: true
+
+module Pocketrb
+  class CLI
+    # Start command - continuous mode with CLI channel
+    class Start < Base
+      desc "start", "Start the agent in continuous mode"
+      option :model, type: :string, aliases: "-m", desc: "Model to use"
+      option :provider, type: :string, aliases: "-p", desc: "LLM provider (anthropic, openrouter)"
+      option :channel, type: :string, aliases: "-c", default: "cli", desc: "Channel to connect to"
+
+      # Starts the agent in continuous mode with CLI channel
+      # @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],
+          max_iterations: config[:max_iterations],
+          mcp_endpoint: config[:mcp_endpoint]
+        )
+
+        say "Pocketrb started with #{config[:provider]}/#{config[:model]}", :green
+        say "Workspace: #{workspace}"
+        say "Memory: #{memory_dir}" if memory_dir != workspace
+        say "Press Ctrl+C to stop\n"
+
+        # Start CLI channel
+        channel = Pocketrb::Channels::CLI.new(bus: bus)
+
+        Async do
+          agent_loop.run
+          channel.run
+        end
+      rescue Interrupt
+        say "\nShutting down...", :yellow
+      end
+
+      default_task :call
+    end
+  end
+end

data/lib/pocketrb/cli/telegram.rb

@@ -0,0 +1,93 @@
+# frozen_string_literal: true
+
+module Pocketrb
+  class CLI
+    # Telegram command - runs agent as a Telegram bot
+    class Telegram < Base
+      desc "telegram", "Run as a Telegram bot"
+      option :model, type: :string, aliases: "-m", desc: "Model to use"
+      option :provider, type: :string, aliases: "-p", desc: "LLM provider"
+      option :token, type: :string, aliases: "-t", desc: "Telegram bot token (or TELEGRAM_BOT_TOKEN env)"
+      option :allowed_users, type: :array, aliases: "-u", desc: "Allowed usernames or user IDs"
+      option :enable_cron, type: :boolean, default: true, desc: "Enable cron/scheduling service"
+      option :autonomous, type: :boolean, default: false, desc: "Skip permission prompts (for sandboxed environments)"
+
+      # Runs the agent as a Telegram bot
+      # @return [void]
+      def call
+        setup_logging
+        workspace = resolve_workspace
+        memory_dir = resolve_memory_dir
+
+        token = options[:token] || ENV.fetch("TELEGRAM_BOT_TOKEN", nil)
+        unless token
+          say "Error: Telegram bot token required", :red
+          say "Set TELEGRAM_BOT_TOKEN env var or use --token", :yellow
+          exit 1
+        end
+
+        config = Pocketrb::Config.load(memory_dir)
+        config[:model] = options[:model] if options[:model]
+        config[:provider] = options[:provider] if options[:provider]
+        config[:autonomous] = options[:autonomous] if options[:autonomous]
+
+        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],
+          max_iterations: config[:max_iterations]
+        )
+
+        # Enable cron service for proactive scheduling
+        cron_service = nil
+        if options[:enable_cron]
+          cron_store = memory_dir.join(".pocketrb", "data", "cron", "jobs.json")
+          cron_service = Pocketrb::Cron::Service.new(
+            store_path: cron_store,
+            on_job: ->(job) { handle_cron_job(agent_loop, bus, job) }
+          )
+          agent_loop.tools.update_context(cron_service: cron_service)
+        end
+
+        say "Starting Pocketrb Telegram Bot", :green
+        say "Provider: #{config[:provider]}/#{config[:model]}"
+        say "Workspace: #{workspace}"
+        say "Memory: #{memory_dir}" if memory_dir != workspace
+        say "Cron: #{options[:enable_cron] ? "enabled" : "disabled"}"
+        say "Autonomous: #{options[:autonomous] ? "yes (claude_cli only)" : "no"}" if options[:autonomous]
+        say "Press Ctrl+C to stop\n"
+
+        channel = Pocketrb::Channels::Telegram.new(
+          bus: bus,
+          token: token,
+          allowed_users: options[:allowed_users]
+        )
+
+        # Set up status context for /status command
+        channel.status_context = {
+          provider: provider,
+          model: config[:model],
+          sessions: agent_loop.sessions,
+          memory_dir: memory_dir,
+          cron_service: cron_service
+        }
+
+        Async do
+          agent_loop.run
+          channel.run
+          cron_service&.start
+        end
+      rescue Interrupt
+        say "\nShutting down Telegram bot...", :yellow
+        cron_service&.stop
+      end
+
+      default_task :call
+    end
+  end
+end

data/lib/pocketrb/cli/version.rb

@@ -0,0 +1,18 @@
+# frozen_string_literal: true
+
+module Pocketrb
+  class CLI
+    # Version command - displays current Pocketrb version
+    class Version < Base
+      desc "version", "Show version"
+      # Displays the current Pocketrb version
+      # @return [void]
+      def call
+        say "Pocketrb #{Pocketrb::VERSION}"
+      end
+
+      # Thor doesn't support default task name, so alias it
+      default_task :call
+    end
+  end
+end

data/lib/pocketrb/cli/whatsapp.rb

@@ -0,0 +1,60 @@
+# frozen_string_literal: true
+
+module Pocketrb
+  class CLI
+    # WhatsApp command - runs agent as a WhatsApp bot
+    class WhatsApp < Base
+      desc "whatsapp", "Run as a WhatsApp bot (requires Node.js bridge)"
+      option :model, type: :string, aliases: "-m", desc: "Model to use"
+      option :provider, type: :string, aliases: "-p", desc: "LLM provider"
+      option :bridge_url, type: :string, default: "ws://localhost:3001", desc: "WhatsApp bridge WebSocket URL"
+      option :allowed_users, type: :array, aliases: "-u", desc: "Allowed phone numbers"
+
+      # Runs the agent as a WhatsApp bot using a WebSocket bridge
+      # @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],
+          max_iterations: config[:max_iterations]
+        )
+
+        say "Starting Pocketrb WhatsApp Bot", :green
+        say "Provider: #{config[:provider]}/#{config[:model]}"
+        say "Bridge: #{options[:bridge_url]}"
+        say "Workspace: #{workspace}"
+        say "Memory: #{memory_dir}" if memory_dir != workspace
+        say "Press Ctrl+C to stop\n"
+
+        channel = Pocketrb::Channels::WhatsApp.new(
+          bus: bus,
+          bridge_url: options[:bridge_url],
+          allowed_users: options[:allowed_users]
+        )
+
+        Async do
+          agent_loop.run
+          channel.run
+        end
+      rescue Interrupt
+        say "\nShutting down WhatsApp bot...", :yellow
+      end
+
+      default_task :call
+    end
+  end
+end

data/lib/pocketrb/cli.rb

@@ -0,0 +1,124 @@
+# frozen_string_literal: true
+
+require "thor"
+
+# Main namespace for Pocketrb gem
+module Pocketrb
+  # Command-line interface
+  class CLI < 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
+
+    # Global options available to all commands
+    class_option :workspace, type: :string, aliases: "-w",
+                             desc: "Workspace directory for file access (default: current directory)"
+    class_option :memory_dir, type: :string, aliases: "-M",
+                              desc: "Memory/persona directory (default: same as workspace)"
+    class_option :verbose, type: :boolean, aliases: "-v",
+                           desc: "Enable verbose output"
+    class_option :quiet, type: :boolean, aliases: "-q",
+                         desc: "Suppress non-essential output"
+
+    # Register subcommands
+    desc "config SUBCOMMAND", "Manage configuration"
+    subcommand "config", CLI::Config
+
+    desc "cron SUBCOMMAND", "Manage scheduled jobs"
+    subcommand "cron", CLI::Cron
+
+    # Register individual commands by delegating to their classes
+    desc "version", "Show version"
+    # Displays the current Pocketrb version
+    # @return [void]
+    def version
+      invoke CLI::Version, :call, [], options
+    end
+
+    desc "skills", "List available skills"
+    # Lists available skills from the workspace
+    # @return [void]
+    def skills
+      invoke CLI::Skills, :call, [], options
+    end
+
+    desc "plans", "List active plans"
+    # Lists all active execution plans
+    # @return [void]
+    def plans
+      invoke CLI::Plans, :call, [], options
+    end
+
+    desc "init", "Initialize a new Pocketrb workspace"
+    # Initializes a new Pocketrb workspace with configuration
+    # @return [void]
+    def init
+      invoke CLI::Init, :call, [], options
+    end
+
+    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
+    # @return [void]
+    def chat
+      invoke CLI::Chat, :call, [], options
+    end
+
+    desc "start", "Start the agent in continuous mode"
+    option :model, type: :string, aliases: "-m", desc: "Model to use"
+    option :provider, type: :string, aliases: "-p", desc: "LLM provider (anthropic, openrouter)"
+    option :channel, type: :string, aliases: "-c", default: "cli", desc: "Channel to connect to"
+    # Starts the agent in continuous mode with CLI channel
+    # @return [void]
+    def start
+      invoke CLI::Start, :call, [], options
+    end
+
+    desc "telegram", "Run as a Telegram bot"
+    option :model, type: :string, aliases: "-m", desc: "Model to use"
+    option :provider, type: :string, aliases: "-p", desc: "LLM provider"
+    option :token, type: :string, aliases: "-t", desc: "Telegram bot token (or TELEGRAM_BOT_TOKEN env)"
+    option :allowed_users, type: :array, aliases: "-u", desc: "Allowed usernames or user IDs"
+    option :enable_cron, type: :boolean, default: true, desc: "Enable cron/scheduling service"
+    option :autonomous, type: :boolean, default: false, desc: "Skip permission prompts (for sandboxed environments)"
+    # Runs the agent as a Telegram bot
+    # @return [void]
+    def telegram
+      invoke CLI::Telegram, :call, [], options
+    end
+
+    desc "whatsapp", "Run as a WhatsApp bot (requires Node.js bridge)"
+    option :model, type: :string, aliases: "-m", desc: "Model to use"
+    option :provider, type: :string, aliases: "-p", desc: "LLM provider"
+    option :bridge_url, type: :string, default: "ws://localhost:3001", desc: "WhatsApp bridge WebSocket URL"
+    option :allowed_users, type: :array, aliases: "-u", desc: "Allowed phone numbers"
+    # Runs the agent as a WhatsApp bot
+    # @return [void]
+    def whatsapp
+      invoke CLI::WhatsApp, :call, [], options
+    end
+
+    desc "gateway", "Start the gateway with all services"
+    option :model, type: :string, aliases: "-m", desc: "Model to use"
+    option :provider, type: :string, aliases: "-p", desc: "LLM provider"
+    option :telegram_token, type: :string, desc: "Telegram bot token"
+    option :telegram_users, type: :array, desc: "Allowed Telegram users"
+    option :whatsapp_bridge, type: :string, default: "ws://localhost:3001", desc: "WhatsApp bridge URL"
+    option :whatsapp_users, type: :array, desc: "Allowed WhatsApp numbers"
+    option :heartbeat_interval, type: :numeric, default: 1800, desc: "Heartbeat interval in seconds"
+    option :enable_cron, type: :boolean, default: true, desc: "Enable cron service"
+    option :enable_heartbeat, type: :boolean, default: true, desc: "Enable heartbeat service"
+    option :autonomous, type: :boolean, default: false, desc: "Skip permission prompts (for sandboxed environments)"
+    # Starts the gateway with all configured services
+    # @return [void]
+    def gateway
+      invoke CLI::Gateway, :call, [], options
+    end
+  end
+end