pocketrb 0.1.0

data/lib/pocketrb/skills/loader.rb

@@ -0,0 +1,164 @@
+# frozen_string_literal: true
+
+require "yaml"
+
+module Pocketrb
+  module Skills
+    # Loads and manages skills from SKILL.md files
+    class Loader
+      SKILL_FILE = "SKILL.md"
+      FRONTMATTER_REGEX = /\A---\s*\n(.+?)\n---\s*\n/m
+
+      attr_reader :workspace, :builtin_dir
+
+      def initialize(workspace:, builtin_dir: nil)
+        @workspace = Pathname.new(workspace)
+        @builtin_dir = if builtin_dir
+                         Pathname.new(builtin_dir)
+                       else
+                         # Default to gem's builtin skills directory
+                         Pocketrb.root.join("lib", "pocketrb", "skills", "builtin")
+                       end
+        @skills_cache = {}
+      end
+
+      # List all available skills
+      # @param filter_unavailable [Boolean] Exclude unavailable skills
+      # @return [Array<Skill>]
+      def list_skills(filter_unavailable: true)
+        skills = []
+
+        # Load builtin skills
+        skills.concat(load_from_directory(@builtin_dir)) if @builtin_dir&.exist?
+
+        # Load workspace skills
+        skills_dir = @workspace.join("skills")
+        skills.concat(load_from_directory(skills_dir)) if skills_dir.exist?
+
+        # Filter unavailable if requested
+        skills = skills.select(&:available?) if filter_unavailable
+
+        skills
+      end
+
+      # Load a specific skill by name
+      # @param name [String] Skill name
+      # @return [Skill|nil]
+      def load_skill(name)
+        @skills_cache[name] ||= find_and_load_skill(name)
+      end
+
+      # Get skills that should always be included
+      # @return [Array<Skill>]
+      def get_always_skills
+        list_skills.select(&:always?)
+      end
+
+      # Get skills triggered by a message
+      # @param text [String] Message text
+      # @return [Array<Skill>]
+      def get_triggered_skills(text)
+        list_skills.select { |s| s.matches?(text) }
+      end
+
+      # Build XML summary of all skills for context
+      # @return [String]
+      def build_skills_summary
+        skills = list_skills
+
+        return "" if skills.empty?
+
+        <<~XML
+          <available-skills>
+          #{skills.map(&:to_summary).join("\n")}
+          </available-skills>
+        XML
+      end
+
+      # Build full prompt content for specific skills
+      # @param skill_names [Array<String>] Skills to include
+      # @return [String]
+      def build_skills_prompt(skill_names)
+        skills = skill_names.filter_map { |name| load_skill(name) }
+        skills.map(&:to_prompt).join("\n\n")
+      end
+
+      # Clear the skills cache
+      def clear_cache!
+        @skills_cache.clear
+      end
+
+      private
+
+      def load_from_directory(dir)
+        return [] unless dir.exist?
+
+        skills = []
+
+        # Direct SKILL.md in skills directory
+        skill_file = dir.join(SKILL_FILE)
+        skills << parse_skill_file(skill_file) if skill_file.exist?
+
+        # Subdirectories with SKILL.md
+        Dir.glob(dir.join("*", SKILL_FILE)).each do |path|
+          skill = parse_skill_file(Pathname.new(path))
+          skills << skill if skill
+        end
+
+        skills.compact
+      end
+
+      def find_and_load_skill(name)
+        # Check workspace skills
+        skill_path = @workspace.join("skills", name, SKILL_FILE)
+        return parse_skill_file(skill_path) if skill_path.exist?
+
+        # Check builtin skills
+        if @builtin_dir
+          builtin_path = @builtin_dir.join(name, SKILL_FILE)
+          return parse_skill_file(builtin_path) if builtin_path.exist?
+        end
+
+        nil
+      end
+
+      def parse_skill_file(path)
+        return nil unless path.exist?
+
+        content = File.read(path)
+        metadata, body = extract_frontmatter(content)
+
+        name = metadata["name"] || path.dirname.basename.to_s
+        description = metadata["description"] || extract_description(body)
+
+        Skill.new(
+          name: name,
+          description: description,
+          content: body,
+          path: path,
+          metadata: metadata
+        )
+      rescue StandardError => e
+        Pocketrb.logger.error("Failed to parse skill at #{path}: #{e.message}")
+        nil
+      end
+
+      def extract_frontmatter(content)
+        if content.match?(FRONTMATTER_REGEX)
+          match = content.match(FRONTMATTER_REGEX)
+          metadata = YAML.safe_load(match[1]) || {}
+          body = content.sub(FRONTMATTER_REGEX, "").strip
+          [metadata, body]
+        else
+          [{}, content.strip]
+        end
+      end
+
+      def extract_description(body)
+        # Extract first line or paragraph as description
+        first_line = body.lines.first&.strip
+        first_line&.gsub(/^#+\s*/, "") || "No description"
+      end
+    end
+  end
+end

data/lib/pocketrb/skills/modify_tool.rb

@@ -0,0 +1,123 @@
+# frozen_string_literal: true
+
+module Pocketrb
+  module Skills
+    # Tool for modifying existing skills
+    class ModifyTool < Tools::Base
+      def name
+        "skill_modify"
+      end
+
+      def description
+        "Modify an existing skill. Can update the content, description, triggers, or other properties."
+      end
+
+      def parameters
+        {
+          type: "object",
+          properties: {
+            skill_name: {
+              type: "string",
+              description: "Name of the skill to modify"
+            },
+            new_content: {
+              type: "string",
+              description: "New content for the skill (replaces existing)"
+            },
+            append_content: {
+              type: "string",
+              description: "Content to append to the skill"
+            },
+            new_description: {
+              type: "string",
+              description: "New description for the skill"
+            },
+            add_triggers: {
+              type: "array",
+              items: { type: "string" },
+              description: "Triggers to add"
+            },
+            remove_triggers: {
+              type: "array",
+              items: { type: "string" },
+              description: "Triggers to remove"
+            },
+            set_always: {
+              type: "boolean",
+              description: "Set whether skill is always loaded"
+            }
+          },
+          required: ["skill_name"]
+        }
+      end
+
+      def execute(
+        skill_name:,
+        new_content: nil,
+        append_content: nil,
+        new_description: nil,
+        add_triggers: nil,
+        remove_triggers: nil,
+        set_always: nil
+      )
+        skill_file = workspace.join("skills", skill_name, "SKILL.md")
+
+        return error("Skill '#{skill_name}' not found") unless skill_file.exist?
+
+        # Parse existing skill
+        content = File.read(skill_file)
+        metadata, body = parse_frontmatter(content)
+
+        # Apply modifications
+        metadata["description"] = new_description if new_description
+
+        if add_triggers
+          metadata["triggers"] ||= []
+          metadata["triggers"] = (metadata["triggers"] + add_triggers).uniq
+        end
+
+        if remove_triggers
+          metadata["triggers"] ||= []
+          metadata["triggers"] -= remove_triggers
+          metadata.delete("triggers") if metadata["triggers"].empty?
+        end
+
+        metadata["always"] = set_always unless set_always.nil?
+
+        if new_content
+          body = new_content
+        elsif append_content
+          body = "#{body}\n\n#{append_content}"
+        end
+
+        # Write updated skill
+        updated_content = build_skill_file(metadata, body)
+        File.write(skill_file, updated_content)
+
+        success("Modified skill '#{skill_name}'")
+      end
+
+      private
+
+      def parse_frontmatter(content)
+        if content.match?(/\A---\s*\n(.+?)\n---\s*\n/m)
+          match = content.match(/\A---\s*\n(.+?)\n---\s*\n/m)
+          metadata = YAML.safe_load(match[1]) || {}
+          body = content.sub(/\A---\s*\n.+?\n---\s*\n/m, "").strip
+          [metadata, body]
+        else
+          [{}, content.strip]
+        end
+      end
+
+      def build_skill_file(metadata, body)
+        <<~MD
+          ---
+          #{metadata.to_yaml.lines[1..].join}---
+
+          #{body}
+        MD
+      end
+    end
+  end
+end

data/lib/pocketrb/skills/skill.rb

@@ -0,0 +1,75 @@
+# frozen_string_literal: true
+
+module Pocketrb
+  module Skills
+    # Represents a loaded skill from SKILL.md
+    class Skill
+      attr_reader :name, :description, :content, :path, :metadata
+
+      def initialize(name:, description:, content:, path:, metadata: {})
+        @name = name
+        @description = description
+        @content = content
+        @path = path
+        @metadata = metadata
+      end
+
+      # Check if skill should always be included in context
+      def always?
+        metadata[:always] == true || metadata["always"] == true
+      end
+
+      # Check if skill is available (meets requirements)
+      def available?
+        requires = metadata[:requires] || metadata["requires"]
+        return true unless requires
+
+        Array(requires).all? { |req| check_requirement(req) }
+      end
+
+      # Get skill triggers/keywords
+      def triggers
+        triggers = metadata[:triggers] || metadata["triggers"] || []
+        Array(triggers)
+      end
+
+      # Check if a message should trigger this skill
+      def matches?(text)
+        return false if triggers.empty?
+
+        text_lower = text.downcase
+        triggers.any? { |t| text_lower.include?(t.downcase) }
+      end
+
+      # Get full prompt content for this skill
+      def to_prompt
+        <<~PROMPT
+          <skill name="#{name}">
+          #{content}
+          </skill>
+        PROMPT
+      end
+
+      # Summary for skills list
+      def to_summary
+        "- #{name}: #{description}"
+      end
+
+      private
+
+      def check_requirement(req)
+        case req
+        when /^env:(.+)/
+          !ENV[::Regexp.last_match(1)].nil?
+        when /^file:(.+)/
+          File.exist?(::Regexp.last_match(1))
+        when /^tool:(.+)/
+          # Would need tool registry context
+          true
+        else
+          true
+        end
+      end
+    end
+  end
+end

data/lib/pocketrb/tools/background_job_manager.rb

@@ -0,0 +1,261 @@
+# frozen_string_literal: true
+
+require "open3"
+
+module Pocketrb
+  module Tools
+    # Manages background jobs for long-running commands
+    class BackgroundJobManager
+      MAX_JOBS = 50
+      MAX_COMPLETED_JOBS = 20
+      MAX_JOB_AGE = 24 * 60 * 60 # 24 hours
+
+      # Commands that should auto-run in background
+      LONG_RUNNING_PATTERNS = [
+        /^apt(-get)?\s+(install|update|upgrade|dist-upgrade|autoremove)/i,
+        /^(npm|yarn|pnpm)\s+(install|ci|update|build|run\s+build)/i,
+        /^pip3?\s+install/i,
+        /^gem\s+install/i,
+        /^bundle\s+(install|update)/i,
+        /^cargo\s+(build|install|run)/i,
+        /^make\b/i,
+        /^docker\s+(build|pull|push|run)/i,
+        /^wget\s/i,
+        /^git\s+(clone|pull|fetch)/i,
+        /sleep\s+\d{2,}/, # sleep 10+ seconds
+        /^python3?\s+.*\.py/i,
+        /^ruby\s+.*\.rb/i,
+        /^node\s+.*\.js/i,
+        /nohup\s/i,
+        /&\s*$/ # ends with &
+      ].freeze
+
+      attr_reader :jobs_dir
+
+      def initialize(workspace:)
+        @workspace = Pathname.new(workspace)
+        @jobs_dir = resolve_jobs_dir
+        @available = setup_jobs_dir!
+        cleanup_stale_jobs if @available
+      end
+
+      # Check if job manager is available (directory accessible)
+      def available?
+        @available
+      end
+
+      private
+
+      def resolve_jobs_dir
+        # Don't create .pocketrb in root filesystem
+        if @workspace.to_s == "/" || !@workspace.writable?
+          Pathname.new(Dir.home).join(".pocketrb", "jobs")
+        else
+          @workspace.join(".pocketrb", "jobs")
+        end
+      end
+
+      def setup_jobs_dir!
+        FileUtils.mkdir_p(@jobs_dir)
+        true
+      rescue Errno::EACCES, Errno::EROFS => e
+        Pocketrb.logger.warn("Cannot create jobs directory #{@jobs_dir}: #{e.message}")
+        false
+      end
+
+      public
+
+      # Check if command should auto-run in background
+      def long_running?(command)
+        return false if command.nil? || command.empty?
+
+        LONG_RUNNING_PATTERNS.any? { |pattern| command.match?(pattern) }
+      end
+
+      # Start a background job
+      def start(command:, working_dir: nil, name: nil)
+        cleanup_stale_jobs
+
+        job_id = "job_#{Time.now.to_i}_#{rand(10_000)}"
+        job_dir = @jobs_dir.join(job_id)
+        FileUtils.mkdir_p(job_dir)
+
+        log_file = job_dir.join("output.log")
+        pid_file = job_dir.join("pid")
+        cmd_file = job_dir.join("command")
+        name_file = job_dir.join("name")
+        status_file = job_dir.join("status")
+
+        File.write(cmd_file, command)
+        File.write(name_file, name || command[0..50])
+        File.write(status_file, "running")
+
+        work_dir = working_dir || @workspace.to_s
+
+        pid = Process.spawn(
+          "bash", "-lc", command,
+          chdir: work_dir,
+          out: [log_file.to_s, "a"],
+          err: [log_file.to_s, "a"],
+          pgroup: true
+        )
+        Process.detach(pid)
+
+        File.write(pid_file, pid.to_s)
+
+        {
+          job_id: job_id,
+          pid: pid,
+          log_file: log_file.to_s
+        }
+      end
+
+      # List all jobs
+      def list
+        return [] unless @jobs_dir.exist?
+
+        Dir.glob(@jobs_dir.join("job_*")).filter_map do |job_dir|
+          job_id = File.basename(job_dir)
+          job_dir_path = Pathname.new(job_dir)
+
+          pid_file = job_dir_path.join("pid")
+          name_file = job_dir_path.join("name")
+
+          next unless pid_file.exist?
+
+          pid = File.read(pid_file).strip.to_i
+          name = name_file.exist? ? File.read(name_file).strip : "unknown"
+          running = process_running?(pid)
+
+          {
+            job_id: job_id,
+            pid: pid,
+            name: name,
+            running: running,
+            created_at: File.mtime(job_dir)
+          }
+        end.sort_by { |j| j[:created_at] }.reverse
+      end
+
+      # Get job status and output
+      def status(job_id)
+        job_dir = @jobs_dir.join(job_id)
+        return nil unless job_dir.exist?
+
+        pid_file = job_dir.join("pid")
+        log_file = job_dir.join("output.log")
+        cmd_file = job_dir.join("command")
+        name_file = job_dir.join("name")
+
+        pid = pid_file.exist? ? File.read(pid_file).strip.to_i : nil
+        running = pid ? process_running?(pid) : false
+        output = log_file.exist? ? truncate_output(File.read(log_file)) : ""
+        command = cmd_file.exist? ? File.read(cmd_file) : "unknown"
+        name = name_file.exist? ? File.read(name_file).strip : "unknown"
+
+        {
+          job_id: job_id,
+          pid: pid,
+          name: name,
+          running: running,
+          output: output,
+          command: command
+        }
+      end
+
+      # Get job output (tail)
+      def output(job_id, lines: 50)
+        log_file = @jobs_dir.join(job_id, "output.log")
+        return nil unless log_file.exist?
+
+        `tail -n #{lines} #{log_file}`
+      end
+
+      # Kill a job
+      def kill(job_id)
+        pid_file = @jobs_dir.join(job_id, "pid")
+        return false unless pid_file.exist?
+
+        pid = File.read(pid_file).strip.to_i
+        return false unless process_running?(pid)
+
+        begin
+          Process.kill("-TERM", pid)
+          sleep 0.5
+          Process.kill("-KILL", pid) if process_running?(pid)
+
+          status_file = @jobs_dir.join(job_id, "status")
+          File.write(status_file, "killed")
+          true
+        rescue Errno::ESRCH
+          false
+        end
+      end
+
+      # Clean up old jobs
+      def cleanup_stale_jobs
+        return 0 unless @jobs_dir.exist?
+
+        jobs = Dir.glob(@jobs_dir.join("job_*")).filter_map do |job_dir|
+          pid_file = File.join(job_dir, "pid")
+          next nil unless File.exist?(pid_file)
+
+          pid = begin
+            File.read(pid_file).strip.to_i
+          rescue StandardError
+            0
+          end
+          running = pid.positive? && process_running?(pid)
+          created = begin
+            File.mtime(job_dir)
+          rescue StandardError
+            Time.now
+          end
+
+          { dir: job_dir, running: running, created: created }
+        end
+
+        completed_jobs = jobs.reject { |j| j[:running] }.sort_by { |j| j[:created] }
+        removed = 0
+
+        # Remove jobs older than MAX_JOB_AGE
+        cutoff = Time.now - MAX_JOB_AGE
+        completed_jobs.each do |job|
+          if job[:created] < cutoff
+            FileUtils.rm_rf(job[:dir])
+            removed += 1
+          end
+        end
+
+        completed_jobs.reject! { |j| j[:created] < cutoff }
+
+        # Keep only MAX_COMPLETED_JOBS
+        while completed_jobs.length > MAX_COMPLETED_JOBS
+          oldest = completed_jobs.shift
+          FileUtils.rm_rf(oldest[:dir])
+          removed += 1
+        end
+
+        removed
+      rescue StandardError => e
+        Pocketrb.logger.warn("Job cleanup error: #{e.message}")
+        0
+      end
+
+      private
+
+      def process_running?(pid)
+        Process.kill(0, pid)
+        true
+      rescue Errno::ESRCH, Errno::EPERM
+        false
+      end
+
+      def truncate_output(output, max_size: 100_000)
+        return output if output.length <= max_size
+
+        "#{output[0...max_size]}\n... (truncated, #{output.length - max_size} more characters)"
+      end
+    end
+  end
+end