pocketrb 0.1.0

data/lib/pocketrb/tools/cron.rb

@@ -0,0 +1,222 @@
+# frozen_string_literal: true
+
+require "time"
+
+module Pocketrb
+  module Tools
+    # Manage scheduled cron jobs - allows agent to be proactive
+    class Cron < Base
+      def name
+        "cron"
+      end
+
+      def description
+        <<~DESC.strip
+          Manage scheduled tasks. Create reminders, follow-ups, or recurring checks.
+          Use this to be proactive - schedule nudges, daily check-ins, or one-time reminders.
+        DESC
+      end
+
+      def parameters
+        {
+          type: "object",
+          properties: {
+            action: {
+              type: "string",
+              enum: %w[add list remove enable disable],
+              description: "Action: add (new job), list (show jobs), remove/enable/disable (manage job)"
+            },
+            name: {
+              type: "string",
+              description: "Job name/label (required for add)"
+            },
+            message: {
+              type: "string",
+              description: "Message to send when job runs (required for add)"
+            },
+            schedule_type: {
+              type: "string",
+              enum: %w[at every cron],
+              description: "Schedule type: 'at' (one-time), 'every' (interval), 'cron' (expression)"
+            },
+            schedule_value: {
+              type: "string",
+              description: "Schedule value: ISO datetime for 'at', seconds for 'every', cron expr for 'cron'"
+            },
+            job_id: {
+              type: "string",
+              description: "Job ID (required for remove/enable/disable)"
+            },
+            deliver: {
+              type: "boolean",
+              description: "If true, deliver message to channel. If false, just wake agent with message."
+            }
+          },
+          required: ["action"]
+        }
+      end
+
+      def available?
+        !cron_service.nil?
+      end
+
+      def execute(action:, name: nil, message: nil, schedule_type: nil, schedule_value: nil, job_id: nil, deliver: true)
+        return error("Cron service not available. Start with --enable-cron flag.") unless cron_service
+
+        case action
+        when "add"
+          add_job(name, message, schedule_type, schedule_value, deliver)
+        when "list"
+          list_jobs
+        when "remove"
+          remove_job(job_id)
+        when "enable"
+          toggle_job(job_id, true)
+        when "disable"
+          toggle_job(job_id, false)
+        else
+          error("Unknown action: #{action}")
+        end
+      end
+
+      private
+
+      def cron_service
+        @context[:cron_service]
+      end
+
+      def current_channel
+        @context[:default_channel] || @context[:channel] || :telegram
+      end
+
+      def current_chat_id
+        @context[:default_chat_id] || @context[:chat_id]
+      end
+
+      def add_job(name, message, schedule_type, schedule_value, deliver)
+        return error("Name required") unless name && !name.empty?
+        return error("Message required") unless message && !message.empty?
+        return error("Schedule type required (at, every, or cron)") unless schedule_type
+
+        schedule = build_schedule(schedule_type, schedule_value)
+        return schedule if schedule.is_a?(String) && schedule.start_with?("Error")
+
+        job = cron_service.add_job(
+          name: name,
+          schedule: schedule,
+          message: message,
+          deliver: deliver,
+          channel: current_channel.to_s,
+          to: current_chat_id
+        )
+
+        next_run = job.state.next_run_at_ms
+        next_run_time = Time.at(next_run / 1000).strftime("%Y-%m-%d %H:%M:%S") if next_run
+
+        success("Created job '#{name}' (ID: #{job.id}). Next run: #{next_run_time || "pending"}")
+      end
+
+      def build_schedule(type, value)
+        case type
+        when "at"
+          # One-time: parse ISO datetime
+          return error("Datetime required for 'at' schedule") unless value
+
+          begin
+            time = Time.parse(value)
+            return error("Scheduled time must be in the future") if time <= Time.now
+
+            ::Pocketrb::Cron::Schedule.new(kind: :at, at_ms: (time.to_f * 1000).to_i)
+          rescue ArgumentError => e
+            error("Invalid datetime: #{e.message}. Use ISO format like '2026-02-04T09:00:00'")
+          end
+
+        when "every"
+          # Interval: parse seconds
+          return error("Interval in seconds required for 'every' schedule") unless value
+
+          seconds = value.to_i
+          return error("Interval must be at least 60 seconds") if seconds < 60
+
+          ::Pocketrb::Cron::Schedule.new(kind: :every, every_ms: seconds * 1000)
+
+        when "cron"
+          # Cron expression
+          return error("Cron expression required") unless value
+
+          ::Pocketrb::Cron::Schedule.new(kind: :cron, expr: value)
+
+        else
+          error("Unknown schedule type: #{type}")
+        end
+      end
+
+      def list_jobs
+        jobs = cron_service.list_jobs(include_disabled: true)
+
+        return "No scheduled jobs." if jobs.empty?
+
+        lines = ["Scheduled Jobs:\n"]
+
+        jobs.each do |job|
+          status = job.enabled ? "✓" : "✗"
+          next_run = if job.state.next_run_at_ms
+                       Time.at(job.state.next_run_at_ms / 1000).strftime("%m/%d %H:%M")
+                     else
+                       "—"
+                     end
+
+          schedule_desc = format_schedule(job.schedule)
+          lines << "#{status} [#{job.id}] #{job.name}"
+          lines << "    Schedule: #{schedule_desc}"
+          lines << "    Next: #{next_run}"
+          lines << "    Message: #{job.payload.message[0..50]}#{"..." if job.payload.message.length > 50}"
+          lines << ""
+        end
+
+        lines.join("\n")
+      end
+
+      def format_schedule(schedule)
+        case schedule.kind
+        when :at
+          time = Time.at(schedule.at_ms / 1000)
+          "One-time at #{time.strftime("%Y-%m-%d %H:%M")}"
+        when :every
+          seconds = schedule.every_ms / 1000
+          if seconds >= 86_400
+            "Every #{seconds / 86_400} day(s)"
+          elsif seconds >= 3600
+            "Every #{seconds / 3600} hour(s)"
+          else
+            "Every #{seconds / 60} minute(s)"
+          end
+        when :cron
+          "Cron: #{schedule.expr}"
+        else
+          "Unknown"
+        end
+      end
+
+      def remove_job(job_id)
+        return error("Job ID required") unless job_id
+
+        if cron_service.remove_job(job_id)
+          success("Removed job: #{job_id}")
+        else
+          error("Job not found: #{job_id}")
+        end
+      end
+
+      def toggle_job(job_id, enabled)
+        return error("Job ID required") unless job_id
+
+        if cron_service.enable_job(job_id, enabled: enabled)
+          success("Job #{job_id} #{enabled ? "enabled" : "disabled"}")
+        else
+          error("Job not found: #{job_id}")
+        end
+      end
+    end
+  end
+end

data/lib/pocketrb/tools/edit_file.rb

@@ -0,0 +1,101 @@
+# frozen_string_literal: true
+
+module Pocketrb
+  module Tools
+    # Edit a file with search/replace
+    class EditFile < Base
+      def name
+        "edit_file"
+      end
+
+      def description
+        "Edit a file by replacing specific text. The old_string must match exactly (including whitespace and indentation). Use for precise edits rather than rewriting entire files."
+      end
+
+      def parameters
+        {
+          type: "object",
+          properties: {
+            path: {
+              type: "string",
+              description: "Path to the file to edit"
+            },
+            old_string: {
+              type: "string",
+              description: "The exact text to find and replace (must match exactly)"
+            },
+            new_string: {
+              type: "string",
+              description: "The text to replace it with"
+            },
+            replace_all: {
+              type: "boolean",
+              description: "Replace all occurrences instead of just the first (default: false)"
+            }
+          },
+          required: %w[path old_string new_string]
+        }
+      end
+
+      def execute(path:, old_string:, new_string:, replace_all: false)
+        resolved = validate_path!(path)
+
+        return error("Not a file: #{path}") unless resolved.file?
+
+        content = File.read(resolved)
+
+        # Check if old_string exists
+        unless content.include?(old_string)
+          # Try to provide helpful feedback
+          return error(suggest_match(content, old_string))
+        end
+
+        # Check for uniqueness if not replace_all
+        if !replace_all && content.scan(old_string).length > 1
+          return error("old_string is not unique in the file (found #{content.scan(old_string).length} occurrences). Use replace_all: true or provide a more specific match.")
+        end
+
+        # Perform replacement
+        new_content = if replace_all
+                        content.gsub(old_string, new_string)
+                      else
+                        content.sub(old_string, new_string)
+                      end
+
+        # Write back
+        File.write(resolved, new_content)
+
+        count = replace_all ? content.scan(old_string).length : 1
+        success("Replaced #{count} occurrence(s) in #{path}")
+      rescue Errno::ENOENT
+        error("File not found: #{path}")
+      rescue Errno::EACCES
+        error("Permission denied: #{path}")
+      end
+
+      private
+
+      def suggest_match(content, old_string)
+        # Try to find similar content
+        lines = content.lines
+        old_lines = old_string.lines
+
+        return "old_string not found in file" if old_lines.empty?
+
+        first_line = old_lines.first.strip
+
+        # Find lines containing the first line's content
+        matches = lines.each_with_index.filter_map do |line, idx|
+          [line, idx + 1] if line.include?(first_line) || first_line.include?(line.strip)
+        end
+
+        if matches.any?
+          match_info = matches.first(3).map { |line, num| "Line #{num}: #{line.strip[0..60]}" }.join("\n")
+          "old_string not found. Similar content found at:\n#{match_info}\n\nCheck for whitespace or indentation differences."
+        else
+          "old_string not found in file. Ensure the text matches exactly, including all whitespace and indentation."
+        end
+      end
+    end
+  end
+end

data/lib/pocketrb/tools/exec.rb

@@ -0,0 +1,194 @@
+# frozen_string_literal: true
+
+require "open3"
+require "timeout"
+
+module Pocketrb
+  module Tools
+    # Execute shell commands with smart timeout and background job support
+    class Exec < Base
+      # Per-operation timeouts (seconds)
+      TIMEOUTS = {
+        simple: 30,     # Quick commands (ls, cat, echo)
+        standard: 120,  # Normal shell commands
+        complex: 300    # Builds, installs
+      }.freeze
+
+      DEFAULT_TIMEOUT = TIMEOUTS[:standard]
+      MAX_OUTPUT_SIZE = 100_000
+
+      # Quick commands that should finish fast
+      QUICK_PATTERNS = [
+        /^(ls|cat|head|tail|echo|pwd|whoami|date|hostname|env)\b/i,
+        /^cd\s/i,
+        /^which\s/i,
+        /^type\s/i,
+        /^file\s/i,
+        /^stat\s/i,
+        /^test\s/i,
+        /^\[/ # test bracket syntax
+      ].freeze
+
+      def name
+        "exec"
+      end
+
+      def description
+        "Execute a shell command. Long-running commands (apt install, npm install, etc.) auto-run in background. Use for git, npm, make, and other development tools."
+      end
+
+      def parameters
+        {
+          type: "object",
+          properties: {
+            command: {
+              type: "string",
+              description: "The shell command to execute"
+            },
+            timeout: {
+              type: "integer",
+              description: "Timeout in seconds (default: auto-detected, max: 600)"
+            },
+            working_dir: {
+              type: "string",
+              description: "Working directory for the command (defaults to workspace)"
+            },
+            background: {
+              type: "boolean",
+              description: "Force run in background (default: auto-detected for long commands)"
+            }
+          },
+          required: ["command"]
+        }
+      end
+
+      def execute(command:, timeout: nil, working_dir: nil, background: nil)
+        work_dir = resolve_working_dir(working_dir)
+        return work_dir if work_dir.is_a?(String) && work_dir.start_with?("Error:")
+
+        return error("Command blocked for security reasons") if dangerous_command?(command)
+
+        # Determine if should run in background
+        run_background = background.nil? ? job_manager.long_running?(command) : background
+
+        if run_background
+          execute_background(command, work_dir)
+        else
+          execute_foreground(command, work_dir, timeout)
+        end
+      end
+
+      private
+
+      def job_manager
+        @job_manager ||= BackgroundJobManager.new(workspace: workspace)
+      end
+
+      def resolve_working_dir(working_dir)
+        if working_dir
+          resolved = resolve_path(working_dir)
+          return error("Working directory outside workspace: #{working_dir}") unless path_allowed?(working_dir)
+
+          resolved.to_s
+        else
+          workspace&.to_s || Dir.pwd
+        end
+      end
+
+      def execute_background(command, work_dir)
+        Pocketrb.logger.debug("Running in background: #{command}")
+
+        result = job_manager.start(
+          command: command,
+          working_dir: work_dir,
+          name: command[0..50]
+        )
+
+        success(<<~OUTPUT)
+          Started in background (detected long-running command)
+          Job ID: #{result[:job_id]}
+          PID: #{result[:pid]}
+          Log: #{result[:log_file]}
+
+          Use 'jobs' tool to check status and output.
+        OUTPUT
+      end
+
+      def execute_foreground(command, work_dir, explicit_timeout)
+        timeout = explicit_timeout || smart_timeout(command)
+        timeout = [timeout, 600].min if timeout
+
+        Pocketrb.logger.debug("Executing: #{command} in #{work_dir} (timeout: #{timeout || "none"})")
+
+        stdout, stderr, status = nil
+
+        begin
+          if timeout
+            Timeout.timeout(timeout) do
+              stdout, stderr, status = Open3.capture3(command, chdir: work_dir)
+            end
+          else
+            stdout, stderr, status = Open3.capture3(command, chdir: work_dir)
+          end
+        rescue Timeout::Error
+          return error("Command timed out after #{timeout} seconds. Consider using background: true for long commands.")
+        end
+
+        format_result(stdout, stderr, status)
+      end
+
+      def smart_timeout(command)
+        return TIMEOUTS[:simple] if quick_command?(command)
+        return nil if job_manager.long_running?(command)
+
+        TIMEOUTS[:standard]
+      end
+
+      def quick_command?(command)
+        return false if command.nil? || command.empty?
+
+        QUICK_PATTERNS.any? { |p| command.match?(p) }
+      end
+
+      def dangerous_command?(command)
+        dangerous_patterns = [
+          %r{\brm\s+-rf\s+[/~]},
+          /\bmkfs\b/,
+          %r{\bdd\s+.*of=/dev},
+          %r{>\s*/dev/sd},
+          /\bshutdown\b/,
+          /\breboot\b/,
+          /\binit\s+0\b/,
+          /:(){ :|:& };:/
+        ]
+
+        dangerous_patterns.any? { |pattern| command.match?(pattern) }
+      end
+
+      def format_result(stdout, stderr, status)
+        output_parts = []
+
+        output_parts << if status.success?
+                          "Exit code: 0"
+                        else
+                          "Exit code: #{status.exitstatus}"
+                        end
+
+        output_parts << "STDOUT:\n#{truncate_output(stdout)}" if stdout && !stdout.empty?
+
+        output_parts << "STDERR:\n#{truncate_output(stderr)}" if stderr && !stderr.empty?
+
+        output_parts << "(no output)" if stdout.to_s.empty? && stderr.to_s.empty?
+
+        output_parts.join("\n\n")
+      end
+
+      def truncate_output(output)
+        return output if output.length <= MAX_OUTPUT_SIZE
+
+        half = MAX_OUTPUT_SIZE / 2
+        "#{output[0...half]}\n\n... [truncated #{output.length - MAX_OUTPUT_SIZE} characters] ...\n\n#{output[-half..]}"
+      end
+    end
+  end
+end

data/lib/pocketrb/tools/jobs.rb

@@ -0,0 +1,127 @@
+# frozen_string_literal: true
+
+module Pocketrb
+  module Tools
+    # Manage background jobs
+    class Jobs < Base
+      def name
+        "jobs"
+      end
+
+      def description
+        "Manage background jobs. List running/completed jobs, get output, or kill jobs."
+      end
+
+      def parameters
+        {
+          type: "object",
+          properties: {
+            action: {
+              type: "string",
+              enum: %w[list status output kill],
+              description: "Action: list (all jobs), status (job details), output (job logs), kill (stop job)"
+            },
+            job_id: {
+              type: "string",
+              description: "Job ID (required for status, output, kill)"
+            },
+            lines: {
+              type: "integer",
+              description: "Number of output lines to show (default: 50)"
+            }
+          },
+          required: ["action"]
+        }
+      end
+
+      def execute(action:, job_id: nil, lines: 50)
+        case action
+        when "list"
+          list_jobs
+        when "status"
+          get_status(job_id)
+        when "output"
+          get_output(job_id, lines)
+        when "kill"
+          kill_job(job_id)
+        else
+          error("Unknown action: #{action}")
+        end
+      end
+
+      private
+
+      def job_manager
+        # Use memory_dir for job storage (falls back to workspace if not set)
+        storage_dir = @context[:memory_dir] || workspace
+        @job_manager ||= BackgroundJobManager.new(workspace: storage_dir)
+      end
+
+      def list_jobs
+        jobs = job_manager.list
+
+        return "No background jobs found." if jobs.empty?
+
+        output = ["Background Jobs:\n"]
+
+        running = jobs.select { |j| j[:running] }
+        completed = jobs.reject { |j| j[:running] }
+
+        if running.any?
+          output << "RUNNING:"
+          running.each do |job|
+            output << "  [#{job[:job_id]}] PID #{job[:pid]} - #{job[:name]}"
+          end
+          output << ""
+        end
+
+        if completed.any?
+          output << "COMPLETED:"
+          completed.first(10).each do |job|
+            output << "  [#{job[:job_id]}] - #{job[:name]}"
+          end
+          output << "  ... and #{completed.length - 10} more" if completed.length > 10
+        end
+
+        output.join("\n")
+      end
+
+      def get_status(job_id)
+        return error("Job ID required") unless job_id
+
+        status = job_manager.status(job_id)
+        return error("Job not found: #{job_id}") unless status
+
+        <<~STATUS
+          Job: #{status[:job_id]}
+          Name: #{status[:name]}
+          Status: #{status[:running] ? "RUNNING" : "COMPLETED"}
+          PID: #{status[:pid]}
+          Command: #{status[:command]}
+
+          Recent output:
+          #{status[:output].lines.last(20).join}
+        STATUS
+      end
+
+      def get_output(job_id, lines)
+        return error("Job ID required") unless job_id
+
+        output = job_manager.output(job_id, lines: lines)
+        return error("Job not found: #{job_id}") unless output
+
+        "Output (last #{lines} lines):\n#{output}"
+      end
+
+      def kill_job(job_id)
+        return error("Job ID required") unless job_id
+
+        if job_manager.kill(job_id)
+          success("Killed job: #{job_id}")
+        else
+          error("Could not kill job: #{job_id} (may not be running)")
+        end
+      end
+    end
+  end
+end