prompt_objects 0.1.0

data/lib/prompt_objects/universal/list_capabilities.rb

@@ -0,0 +1,55 @@
+# frozen_string_literal: true
+
+module PromptObjects
+  module Universal
+    # Universal capability to list all available capabilities in the registry.
+    # This helps POs discover what tools exist.
+    class ListCapabilities < Primitive
+      def name
+        "list_capabilities"
+      end
+
+      def description
+        "List all available capabilities (primitives and prompt objects) in the system. Useful for discovering what tools exist before creating new ones."
+      end
+
+      def parameters
+        {
+          type: "object",
+          properties: {
+            type: {
+              type: "string",
+              enum: ["all", "primitives", "prompt_objects"],
+              description: "Filter by type. Default is 'all'."
+            }
+          },
+          required: []
+        }
+      end
+
+      def receive(message, context:)
+        filter = message[:type] || message["type"] || "all"
+
+        capabilities = case filter
+        when "primitives"
+          context.env.registry.primitives
+        when "prompt_objects"
+          context.env.registry.prompt_objects
+        else
+          context.env.registry.all
+        end
+
+        if capabilities.empty?
+          return "No capabilities found."
+        end
+
+        lines = capabilities.map do |cap|
+          type_label = cap.is_a?(PromptObject) ? "[PO]" : "[Primitive]"
+          "- #{cap.name} #{type_label}: #{cap.description}"
+        end
+
+        "Available capabilities:\n#{lines.join("\n")}"
+      end
+    end
+  end
+end

data/lib/prompt_objects/universal/list_primitives.rb

@@ -0,0 +1,145 @@
+# frozen_string_literal: true
+
+module PromptObjects
+  module Universal
+    # Universal capability to list available primitives.
+    # Shows stdlib primitives, custom (environment) primitives, and which ones
+    # the current PO has active.
+    class ListPrimitives < Primitive
+      # Names of stdlib primitives (built into the framework)
+      STDLIB_PRIMITIVES = %w[read_file list_files write_file http_get].freeze
+
+      def name
+        "list_primitives"
+      end
+
+      def description
+        "List available primitives (deterministic Ruby tools). Filter by type: stdlib (built-in), custom (environment-specific), active (on this PO), or available (all)."
+      end
+
+      def parameters
+        {
+          type: "object",
+          properties: {
+            filter: {
+              type: "string",
+              enum: ["available", "active", "stdlib", "custom"],
+              description: "Filter primitives: 'available' (all), 'active' (currently on this PO), 'stdlib' (built-in), 'custom' (environment-specific). Default: 'available'"
+            }
+          },
+          required: []
+        }
+      end
+
+      def receive(message, context:)
+        filter = (message[:filter] || message["filter"] || "available").to_s
+
+        case filter
+        when "stdlib"
+          list_stdlib(context)
+        when "custom"
+          list_custom(context)
+        when "active"
+          list_active(context)
+        when "available"
+          list_available(context)
+        else
+          "Error: Unknown filter '#{filter}'. Use: available, active, stdlib, or custom."
+        end
+      end
+
+      private
+
+      def list_stdlib(context)
+        primitives = STDLIB_PRIMITIVES.filter_map do |name|
+          prim = context.env.registry.get(name)
+          prim if prim.is_a?(Primitive)
+        end
+
+        format_list("Stdlib Primitives (built-in)", primitives)
+      end
+
+      def list_custom(context)
+        primitives = context.env.registry.primitives.reject do |prim|
+          STDLIB_PRIMITIVES.include?(prim.name) || universal_primitive?(prim)
+        end
+
+        if primitives.empty?
+          "No custom primitives found.\nCustom primitives are stored in: #{context.env.primitives_dir}"
+        else
+          format_list("Custom Primitives (environment-specific)", primitives)
+        end
+      end
+
+      def list_active(context)
+        caller = context.calling_po
+        unless caller
+          return "Error: No calling PO context. This filter shows primitives active on the current PO."
+        end
+
+        po = context.env.registry.get(caller)
+        unless po.is_a?(PromptObject)
+          return "Error: Could not find calling PO '#{caller}'."
+        end
+
+        capabilities = po.config["capabilities"] || []
+        active_primitives = capabilities.filter_map do |cap_name|
+          cap = context.env.registry.get(cap_name)
+          cap if cap.is_a?(Primitive) && !universal_primitive?(cap)
+        end
+
+        if active_primitives.empty?
+          "No primitives currently active on #{caller}.\nUse add_primitive to add primitives to your capabilities."
+        else
+          format_list("Active Primitives on #{caller}", active_primitives)
+        end
+      end
+
+      def list_available(context)
+        # All registered primitives except universal ones
+        primitives = context.env.registry.primitives.reject { |p| universal_primitive?(p) }
+
+        # Categorize them
+        stdlib = primitives.select { |p| STDLIB_PRIMITIVES.include?(p.name) }
+        custom = primitives.reject { |p| STDLIB_PRIMITIVES.include?(p.name) }
+
+        lines = []
+
+        unless stdlib.empty?
+          lines << "## Stdlib Primitives (built-in)"
+          stdlib.each { |p| lines << format_primitive(p) }
+          lines << ""
+        end
+
+        unless custom.empty?
+          lines << "## Custom Primitives (environment-specific)"
+          custom.each { |p| lines << format_primitive(p) }
+          lines << ""
+        end
+
+        if lines.empty?
+          "No primitives available."
+        else
+          lines.join("\n")
+        end
+      end
+
+      def format_list(title, primitives)
+        return "#{title}: (none)" if primitives.empty?
+
+        lines = ["## #{title}", ""]
+        primitives.each { |p| lines << format_primitive(p) }
+        lines.join("\n")
+      end
+
+      def format_primitive(primitive)
+        "- **#{primitive.name}**: #{primitive.description}"
+      end
+
+      def universal_primitive?(primitive)
+        # Universal capabilities live in PromptObjects::Universal module
+        primitive.class.name&.start_with?("PromptObjects::Universal")
+      end
+    end
+  end
+end

data/lib/prompt_objects/universal/modify_primitive.rb

@@ -0,0 +1,180 @@
+# frozen_string_literal: true
+
+require "fileutils"
+
+module PromptObjects
+  module Universal
+    # Universal capability to modify existing primitives.
+    # Allows POs to fix or improve their primitives.
+    class ModifyPrimitive < Primitive
+      # Stdlib primitives cannot be modified
+      STDLIB_PRIMITIVES = %w[read_file list_files write_file http_get].freeze
+
+      def name
+        "modify_primitive"
+      end
+
+      def description
+        "Modify an existing primitive's code. Only custom (environment) primitives can be modified, not stdlib."
+      end
+
+      def parameters
+        {
+          type: "object",
+          properties: {
+            name: {
+              type: "string",
+              description: "Name of the primitive to modify"
+            },
+            code: {
+              type: "string",
+              description: "New Ruby code for the primitive's receive method"
+            },
+            description: {
+              type: "string",
+              description: "Optional: Update the description"
+            },
+            parameters_schema: {
+              type: "object",
+              description: "Optional: Update the parameters schema"
+            },
+            reason: {
+              type: "string",
+              description: "Brief explanation of why this change is needed (for commit message)"
+            }
+          },
+          required: ["name", "code"]
+        }
+      end
+
+      def receive(message, context:)
+        prim_name = message[:name] || message["name"]
+        new_code = message[:code] || message["code"]
+        new_description = message[:description] || message["description"]
+        new_params_schema = message[:parameters_schema] || message["parameters_schema"]
+        reason = message[:reason] || message["reason"] || "Updated primitive"
+
+        # Find the primitive
+        primitive = context.env.registry.get(prim_name)
+        unless primitive
+          return "Error: Primitive '#{prim_name}' not found."
+        end
+
+        unless primitive.is_a?(Primitive)
+          return "Error: '#{prim_name}' is not a primitive."
+        end
+
+        # Check if it's a stdlib primitive
+        if STDLIB_PRIMITIVES.include?(prim_name)
+          return "Error: Cannot modify stdlib primitive '#{prim_name}'. Stdlib primitives are built into the framework."
+        end
+
+        # Check if it's a universal capability
+        if universal_primitive?(primitive)
+          return "Error: Cannot modify universal capability '#{prim_name}'."
+        end
+
+        # Find the primitive file
+        path = File.join(context.env.primitives_dir, "#{prim_name}.rb")
+        unless File.exist?(path)
+          return "Error: Cannot find primitive file at #{path}. Only custom primitives can be modified."
+        end
+
+        # Validate code syntax
+        syntax_error = validate_syntax(new_code)
+        return "Error: Invalid Ruby syntax - #{syntax_error}" if syntax_error
+
+        # Get current values if not provided
+        description = new_description || primitive.description
+        params_schema = new_params_schema || primitive.parameters
+
+        # Generate updated Ruby class
+        class_name = prim_name.split("_").map(&:capitalize).join
+        ruby_content = generate_ruby_class(class_name, prim_name, description, params_schema, new_code)
+
+        # Write the updated file
+        File.write(path, ruby_content, encoding: "UTF-8")
+
+        # Reload the primitive
+        begin
+          # Remove old constant to allow re-definition
+          if PromptObjects::Primitives.const_defined?(class_name)
+            PromptObjects::Primitives.send(:remove_const, class_name)
+          end
+
+          load(path)
+          klass = PromptObjects::Primitives.const_get(class_name)
+          new_instance = klass.new
+
+          # Re-register with the new instance
+          context.env.registry.register(new_instance)
+
+          # Auto-commit if in environment mode
+          if context.env.environment? && context.env.auto_commit
+            commit_message = "Modified primitive '#{prim_name}': #{reason}"
+            context.env.save(commit_message)
+          end
+
+          "Modified primitive '#{prim_name}'. Changes saved to #{path}."
+        rescue SyntaxError => e
+          "Error: Invalid Ruby syntax in generated code - #{e.message}"
+        rescue StandardError => e
+          "Error reloading primitive: #{e.message}"
+        end
+      end
+
+      private
+
+      def universal_primitive?(primitive)
+        primitive.class.name&.start_with?("PromptObjects::Universal")
+      end
+
+      def validate_syntax(code)
+        eval("proc { #{code} }")
+        nil
+      rescue SyntaxError => e
+        e.message.sub(/^\(eval\):\d+: /, "")
+      rescue StandardError
+        nil
+      end
+
+      def generate_ruby_class(class_name, prim_name, description, params_schema, code)
+        escaped_desc = description.gsub('\\', '\\\\\\\\').gsub('"', '\\"')
+
+        <<~RUBY
+          # frozen_string_literal: true
+          # Auto-generated primitive: #{prim_name}
+          # Modified at #{Time.now.iso8601}
+
+          module PromptObjects
+            module Primitives
+              class #{class_name} < Primitive
+                def name
+                  "#{prim_name}"
+                end
+
+                def description
+                  "#{escaped_desc}"
+                end
+
+                def parameters
+                  #{params_schema.inspect}
+                end
+
+                def receive(message, context:)
+                  #{indent_code(code, 10)}
+                end
+              end
+            end
+          end
+        RUBY
+      end
+
+      def indent_code(code, spaces)
+        code.lines.map.with_index do |line, i|
+          i.zero? ? line.rstrip : (" " * spaces) + line.rstrip
+        end.join("\n")
+      end
+    end
+  end
+end

data/lib/prompt_objects/universal/request_primitive.rb

@@ -0,0 +1,287 @@
+# frozen_string_literal: true
+
+module PromptObjects
+  module Universal
+    # Universal capability to request a primitive from the human.
+    # Similar to ask_human but specifically for requesting new tools.
+    # The human can approve, modify, or reject the request.
+    class RequestPrimitive < Primitive
+      def name
+        "request_primitive"
+      end
+
+      def description
+        "Request a new primitive from the human. Use this when you need a tool that doesn't exist. The human can approve and create it, or reject the request."
+      end
+
+      def parameters
+        {
+          type: "object",
+          properties: {
+            name: {
+              type: "string",
+              description: "Suggested name for the primitive (lowercase, underscores)"
+            },
+            description: {
+              type: "string",
+              description: "What this primitive should do"
+            },
+            reason: {
+              type: "string",
+              description: "Why you need this primitive"
+            },
+            suggested_code: {
+              type: "string",
+              description: "Optional: Your suggested Ruby implementation for the receive method"
+            },
+            parameters_schema: {
+              type: "object",
+              description: "Optional: Suggested JSON Schema for parameters"
+            }
+          },
+          required: ["name", "description", "reason"]
+        }
+      end
+
+      def receive(message, context:)
+        prim_name = message[:name] || message["name"]
+        description = message[:description] || message["description"]
+        reason = message[:reason] || message["reason"]
+        suggested_code = message[:suggested_code] || message["suggested_code"]
+        params_schema = message[:parameters_schema] || message["parameters_schema"]
+
+        # Validate name format
+        unless prim_name && prim_name.match?(/\A[a-z][a-z0-9_]*\z/)
+          return "Error: Name must be lowercase letters, numbers, and underscores, starting with a letter."
+        end
+
+        # Check if already exists
+        if context.env.registry.exists?(prim_name)
+          return "Error: A capability named '#{prim_name}' already exists."
+        end
+
+        # In TUI mode, use the human queue
+        if context.tui_mode && context.human_queue
+          return receive_tui(prim_name, description, reason, suggested_code, params_schema, context)
+        end
+
+        # REPL mode - use stdin directly
+        receive_repl(prim_name, description, reason, suggested_code, params_schema, context)
+      end
+
+      private
+
+      def receive_tui(prim_name, description, reason, suggested_code, params_schema, context)
+        # Build the question with all details
+        question = build_request_question(prim_name, description, reason, suggested_code)
+
+        # Queue the request
+        request = context.human_queue.enqueue(
+          capability: context.current_capability,
+          question: question,
+          options: ["approve", "reject"]
+        )
+
+        # Log to message bus
+        context.bus.publish(
+          from: context.current_capability,
+          to: "human",
+          message: "[primitive request] #{prim_name}: #{description}"
+        )
+
+        # Wait for response
+        response = request.wait_for_response
+
+        # Handle the response
+        handle_response(response, prim_name, description, suggested_code, params_schema, context)
+      end
+
+      def receive_repl(prim_name, description, reason, suggested_code, params_schema, context)
+        puts
+        puts "┌─ Primitive Request ─────────────────────────────────────────┐"
+        puts "│"
+        puts "│  From: #{context.calling_po || context.current_capability}"
+        puts "│  Requested: #{prim_name}"
+        puts "│"
+        puts "│  Description: #{description}"
+        puts "│"
+        puts "│  Reason: #{reason}"
+        puts "│"
+
+        if suggested_code
+          puts "│  Suggested Code:"
+          suggested_code.lines.each { |line| puts "│    #{line}" }
+          puts "│"
+        end
+
+        puts "├─────────────────────────────────────────────────────────────┤"
+        puts "│  [a] Approve (use suggested code)"
+        puts "│  [e] Edit (provide different code)"
+        puts "│  [r] Reject"
+        puts "└─────────────────────────────────────────────────────────────┘"
+        print "Your choice: "
+
+        choice = $stdin.gets&.chomp&.downcase
+
+        case choice
+        when "a", "approve"
+          if suggested_code
+            create_and_register(prim_name, description, suggested_code, params_schema, context)
+          else
+            puts "No suggested code provided. Please enter the code (end with 'END' on its own line):"
+            code = read_multiline_input
+            create_and_register(prim_name, description, code, params_schema, context)
+          end
+        when "e", "edit"
+          puts "Enter the Ruby code for the receive method (end with 'END' on its own line):"
+          code = read_multiline_input
+          create_and_register(prim_name, description, code, params_schema, context)
+        when "r", "reject"
+          "Request rejected by human."
+        else
+          "Request deferred."
+        end
+      end
+
+      def build_request_question(prim_name, description, reason, suggested_code)
+        lines = []
+        lines << "**Primitive Request: #{prim_name}**"
+        lines << ""
+        lines << "**Description:** #{description}"
+        lines << ""
+        lines << "**Reason:** #{reason}"
+
+        if suggested_code
+          lines << ""
+          lines << "**Suggested Code:**"
+          lines << "```ruby"
+          lines << suggested_code
+          lines << "```"
+        end
+
+        lines.join("\n")
+      end
+
+      def handle_response(response, prim_name, description, suggested_code, params_schema, context)
+        case response.to_s.downcase
+        when "approve", "approved", "yes", "y"
+          if suggested_code
+            create_and_register(prim_name, description, suggested_code, params_schema, context)
+          else
+            "Request approved but no code provided. Human should create the primitive manually."
+          end
+        when "reject", "rejected", "no", "n"
+          "Request rejected by human."
+        else
+          # Treat anything else as custom code provided by human
+          if response && !response.strip.empty?
+            create_and_register(prim_name, description, response, params_schema, context)
+          else
+            "Request deferred."
+          end
+        end
+      end
+
+      def create_and_register(prim_name, description, code, params_schema, context)
+        params_schema ||= { type: "object", properties: {}, required: [] }
+
+        # Validate syntax
+        begin
+          eval("proc { #{code} }")
+        rescue SyntaxError => e
+          return "Error: Invalid Ruby syntax - #{e.message}"
+        end
+
+        # Generate and write the file
+        class_name = prim_name.split("_").map(&:capitalize).join
+        ruby_content = generate_ruby_class(class_name, prim_name, description, params_schema, code)
+
+        FileUtils.mkdir_p(context.env.primitives_dir)
+        path = File.join(context.env.primitives_dir, "#{prim_name}.rb")
+        File.write(path, ruby_content, encoding: "UTF-8")
+
+        # Load and register
+        begin
+          load(path)
+          klass = PromptObjects::Primitives.const_get(class_name)
+          context.env.registry.register(klass.new)
+        rescue StandardError => e
+          File.delete(path) if File.exist?(path)
+          return "Error creating primitive: #{e.message}"
+        end
+
+        # Auto-add to the requesting PO
+        saved = false
+        if context.calling_po
+          caller_po = context.env.registry.get(context.calling_po)
+          if caller_po.is_a?(PromptObject)
+            caller_po.config["capabilities"] ||= []
+            unless caller_po.config["capabilities"].include?(prim_name)
+              caller_po.config["capabilities"] << prim_name
+              saved = caller_po.save
+            end
+          end
+        end
+
+        # Log to bus
+        context.bus.publish(
+          from: "human",
+          to: context.current_capability,
+          message: "[approved] Created primitive '#{prim_name}'"
+        )
+
+        save_msg = saved ? " and saved to file" : ""
+        "Primitive '#{prim_name}' created and added to your capabilities#{save_msg}."
+      end
+
+      def generate_ruby_class(class_name, prim_name, description, params_schema, code)
+        escaped_desc = description.gsub('\\', '\\\\\\\\').gsub('"', '\\"')
+
+        <<~RUBY
+          # frozen_string_literal: true
+          # Requested primitive: #{prim_name}
+          # Created at #{Time.now.iso8601}
+
+          module PromptObjects
+            module Primitives
+              class #{class_name} < Primitive
+                def name
+                  "#{prim_name}"
+                end
+
+                def description
+                  "#{escaped_desc}"
+                end
+
+                def parameters
+                  #{params_schema.inspect}
+                end
+
+                def receive(message, context:)
+                  #{indent_code(code, 10)}
+                end
+              end
+            end
+          end
+        RUBY
+      end
+
+      def indent_code(code, spaces)
+        code.lines.map.with_index do |line, i|
+          i.zero? ? line.rstrip : (" " * spaces) + line.rstrip
+        end.join("\n")
+      end
+
+      def read_multiline_input
+        lines = []
+        loop do
+          line = $stdin.gets
+          break if line.nil? || line.strip == "END"
+
+          lines << line
+        end
+        lines.join
+      end
+    end
+  end
+end