prompt_objects 0.1.0

data/lib/prompt_objects/primitives/http_get.rb

@@ -0,0 +1,72 @@
+# frozen_string_literal: true
+
+require "net/http"
+require "uri"
+
+module PromptObjects
+  module Primitives
+    # Primitive capability to fetch content from a URL.
+    class HttpGet < Primitive
+      def name
+        "http_get"
+      end
+
+      def description
+        "Fetch content from a URL via HTTP GET request"
+      end
+
+      def parameters
+        {
+          type: "object",
+          properties: {
+            url: {
+              type: "string",
+              description: "The URL to fetch"
+            }
+          },
+          required: ["url"]
+        }
+      end
+
+      def receive(message, context:)
+        url = message[:url] || message["url"]
+
+        return "Error: URL is required" if url.nil? || url.empty?
+
+        begin
+          uri = URI.parse(url)
+
+          unless %w[http https].include?(uri.scheme)
+            return "Error: Only http and https URLs are supported"
+          end
+
+          response = Net::HTTP.get_response(uri)
+
+          case response
+          when Net::HTTPSuccess
+            content = response.body.to_s
+
+            # Truncate very large responses
+            if content.length > 50_000
+              content = content[0, 50_000] + "\n\n... [truncated, response is #{content.length} bytes]"
+            end
+
+            content
+          when Net::HTTPRedirection
+            "Redirected to: #{response['location']}"
+          else
+            "HTTP Error: #{response.code} #{response.message}"
+          end
+        rescue URI::InvalidURIError
+          "Error: Invalid URL format"
+        rescue SocketError => e
+          "Error: Could not connect - #{e.message}"
+        rescue Timeout::Error
+          "Error: Request timed out"
+        rescue StandardError => e
+          "Error fetching URL: #{e.message}"
+        end
+      end
+    end
+  end
+end

data/lib/prompt_objects/primitives/list_files.rb

@@ -0,0 +1,95 @@
+# frozen_string_literal: true
+
+module PromptObjects
+  module Primitives
+    # Primitive capability to list files in a directory.
+    class ListFiles < Primitive
+      def name
+        "list_files"
+      end
+
+      def description
+        "List files and directories in a given path"
+      end
+
+      def parameters
+        {
+          type: "object",
+          properties: {
+            path: {
+              type: "string",
+              description: "The directory path to list (defaults to current directory)"
+            }
+          },
+          required: []
+        }
+      end
+
+      def receive(message, context:)
+        path = extract_path(message)
+        path = "." if path.nil? || path.empty?
+
+        safe_path = File.expand_path(path)
+
+        unless File.exist?(safe_path)
+          return "Error: Path not found: #{path}"
+        end
+
+        unless File.directory?(safe_path)
+          return "Error: Not a directory: #{path}"
+        end
+
+        entries = Dir.entries(safe_path)
+          .reject { |e| e.start_with?(".") } # Hide hidden files
+          .sort
+          .map { |entry| format_entry(safe_path, entry) }
+
+        if entries.empty?
+          "Directory is empty: #{path}"
+        else
+          entries.join("\n")
+        end
+      rescue Errno::EACCES
+        "Error: Permission denied: #{path}"
+      rescue StandardError => e
+        "Error listing directory: #{e.message}"
+      end
+
+      private
+
+      def extract_path(message)
+        case message
+        when Hash
+          message[:path] || message["path"]
+        when String
+          message
+        when NilClass
+          "."
+        else
+          message.to_s
+        end
+      end
+
+      def format_entry(base_path, entry)
+        full_path = File.join(base_path, entry)
+
+        if File.directory?(full_path)
+          "#{entry}/"
+        else
+          size = File.size(full_path)
+          "#{entry} (#{human_size(size)})"
+        end
+      end
+
+      def human_size(bytes)
+        return "0 B" if bytes == 0
+
+        units = ["B", "KB", "MB", "GB"]
+        exp = (Math.log(bytes) / Math.log(1024)).to_i
+        exp = units.length - 1 if exp >= units.length
+
+        "%.1f %s" % [bytes.to_f / (1024 ** exp), units[exp]]
+      end
+    end
+  end
+end

data/lib/prompt_objects/primitives/read_file.rb

@@ -0,0 +1,81 @@
+# frozen_string_literal: true
+
+module PromptObjects
+  module Primitives
+    # Primitive capability to read file contents.
+    class ReadFile < Primitive
+      def name
+        "read_file"
+      end
+
+      def description
+        "Read the contents of a text file"
+      end
+
+      def parameters
+        {
+          type: "object",
+          properties: {
+            path: {
+              type: "string",
+              description: "The path to the file to read"
+            }
+          },
+          required: ["path"]
+        }
+      end
+
+      def receive(message, context:)
+        path = extract_path(message)
+        safe_path = validate_path(path)
+
+        unless File.exist?(safe_path)
+          return "Error: File not found: #{path}"
+        end
+
+        unless File.file?(safe_path)
+          return "Error: Not a file: #{path}"
+        end
+
+        content = File.read(safe_path, encoding: "UTF-8")
+
+        # Truncate very large files
+        if content.length > 50_000
+          content = content[0, 50_000] + "\n\n... [truncated, file is #{content.length} bytes]"
+        end
+
+        content
+      rescue Errno::EACCES
+        "Error: Permission denied: #{path}"
+      rescue StandardError => e
+        "Error reading file: #{e.message}"
+      end
+
+      private
+
+      def extract_path(message)
+        case message
+        when Hash
+          message[:path] || message["path"]
+        when String
+          message
+        else
+          message.to_s
+        end
+      end
+
+      def validate_path(path)
+        # Expand and normalize the path
+        expanded = File.expand_path(path)
+
+        # Basic safety: don't allow reading outside current directory tree
+        # In a real implementation, you'd want more robust sandboxing
+        cwd = File.expand_path(".")
+
+        # Allow absolute paths but warn if outside cwd
+        # For now, we'll be permissive but could restrict this
+        expanded
+      end
+    end
+  end
+end

data/lib/prompt_objects/primitives/write_file.rb

@@ -0,0 +1,73 @@
+# frozen_string_literal: true
+
+module PromptObjects
+  module Primitives
+    # Primitive capability to write content to a file.
+    class WriteFile < Primitive
+      def name
+        "write_file"
+      end
+
+      def description
+        "Write content to a file (creates or overwrites)"
+      end
+
+      def parameters
+        {
+          type: "object",
+          properties: {
+            path: {
+              type: "string",
+              description: "The path to the file to write"
+            },
+            content: {
+              type: "string",
+              description: "The content to write to the file"
+            }
+          },
+          required: ["path", "content"]
+        }
+      end
+
+      def receive(message, context:)
+        path = extract_param(message, :path)
+        content = extract_param(message, :content)
+
+        if path.nil? || path.empty?
+          return "Error: path is required"
+        end
+
+        if content.nil?
+          return "Error: content is required"
+        end
+
+        safe_path = File.expand_path(path)
+
+        # Create parent directories if they don't exist
+        dir = File.dirname(safe_path)
+        FileUtils.mkdir_p(dir) unless File.directory?(dir)
+
+        File.write(safe_path, content, encoding: "UTF-8")
+
+        "Successfully wrote #{content.length} bytes to #{path}"
+      rescue Errno::EACCES
+        "Error: Permission denied: #{path}"
+      rescue StandardError => e
+        "Error writing file: #{e.message}"
+      end
+
+      private
+
+      def extract_param(message, key)
+        case message
+        when Hash
+          message[key] || message[key.to_s]
+        else
+          nil
+        end
+      end
+    end
+  end
+end
+
+require "fileutils"