agentic 0.1.0 → 0.2.0

data/lib/agentic/capabilities/examples.rb

@@ -0,0 +1,530 @@
+# frozen_string_literal: true
+
+require_relative "../capability_specification"
+require_relative "../capability_provider"
+require_relative "../agent_capability_registry"
+
+module Agentic
+  module Capabilities
+    # Example capabilities for common tasks
+    module Examples
+      class << self
+        # Register all example capabilities
+        # @return [void]
+        def register_all
+          register_text_generation
+          register_web_search
+          register_data_analysis
+          register_code_generation
+          register_summarization
+          register_brainstorming
+          register_structured_extraction
+        end
+
+        # Register a text generation capability
+        # @return [CapabilitySpecification] The registered capability
+        def register_text_generation
+          spec = CapabilitySpecification.new(
+            name: "text_generation",
+            description: "Generates text based on a prompt",
+            version: "1.0.0",
+            inputs: {
+              prompt: {
+                type: "string",
+                required: true,
+                description: "The prompt to generate text from"
+              },
+              max_tokens: {
+                type: "integer",
+                description: "Maximum number of tokens to generate"
+              },
+              temperature: {
+                type: "number",
+                description: "Sampling temperature (0.0-1.0)"
+              }
+            },
+            outputs: {
+              response: {
+                type: "string",
+                required: true,
+                description: "The generated text"
+              }
+            }
+          )
+
+          provider = CapabilityProvider.new(
+            capability: spec,
+            implementation: lambda do |inputs|
+              # Get the LLM client
+              llm_config = LlmConfig.new
+              llm_config.max_tokens = inputs[:max_tokens] if inputs[:max_tokens]
+              llm_config.temperature = inputs[:temperature] if inputs[:temperature]
+
+              client = Agentic.client(llm_config)
+
+              # Generate text
+              response = client.complete(prompt: inputs[:prompt])
+
+              {response: response.to_s}
+            end
+          )
+
+          registry.register(spec, provider)
+        end
+
+        # Register a web search capability
+        # @return [CapabilitySpecification] The registered capability
+        def register_web_search
+          spec = CapabilitySpecification.new(
+            name: "web_search",
+            description: "Searches the web for information",
+            version: "1.0.0",
+            inputs: {
+              query: {
+                type: "string",
+                required: true,
+                description: "The search query"
+              },
+              num_results: {
+                type: "integer",
+                description: "Number of results to return"
+              }
+            },
+            outputs: {
+              results: {
+                type: "array",
+                required: true,
+                description: "The search results"
+              },
+              sources: {
+                type: "array",
+                description: "The sources of the results"
+              }
+            }
+          )
+
+          provider = CapabilityProvider.new(
+            capability: spec,
+            implementation: lambda do |inputs|
+              # This is a mock implementation
+              # In a real implementation, you would use a search API or web scraping
+
+              query = inputs[:query]
+              num_results = inputs[:num_results] || 3
+
+              results = num_results.times.map do |i|
+                "Result #{i + 1} for query: #{query}"
+              end
+
+              sources = num_results.times.map do |i|
+                "https://example.com/result#{i + 1}"
+              end
+
+              {
+                results: results,
+                sources: sources
+              }
+            end
+          )
+
+          registry.register(spec, provider)
+        end
+
+        # Register a data analysis capability
+        # @return [CapabilitySpecification] The registered capability
+        def register_data_analysis
+          spec = CapabilitySpecification.new(
+            name: "data_analysis",
+            description: "Analyzes data and extracts insights",
+            version: "1.0.0",
+            inputs: {
+              data: {
+                type: "object",
+                required: true,
+                description: "The data to analyze"
+              },
+              analysis_type: {
+                type: "string",
+                description: "The type of analysis to perform"
+              }
+            },
+            outputs: {
+              insights: {
+                type: "array",
+                required: true,
+                description: "The extracted insights"
+              },
+              summary: {
+                type: "string",
+                required: true,
+                description: "A summary of the analysis"
+              }
+            },
+            dependencies: [
+              {name: "text_generation", version: "1.0.0"}
+            ]
+          )
+
+          provider = CapabilityProvider.new(
+            capability: spec,
+            implementation: lambda do |inputs|
+              data = inputs[:data]
+              analysis_type = inputs[:analysis_type] || "basic"
+
+              # Get the text generation capability
+              text_gen_provider = registry.get_provider("text_generation")
+
+              # Generate insights based on the data
+              insights_prompt = "Analyze the following data using #{analysis_type} analysis and provide key insights:\n\n#{data.inspect}"
+              insights_response = text_gen_provider.execute(prompt: insights_prompt)[:response]
+
+              # Parse insights
+              insights = insights_response.split("\n").map(&:strip).reject(&:empty?)
+
+              # Generate summary
+              summary_prompt = "Summarize the following insights in one paragraph:\n\n#{insights.join("\n")}"
+              summary = text_gen_provider.execute(prompt: summary_prompt)[:response]
+
+              {
+                insights: insights,
+                summary: summary
+              }
+            end
+          )
+
+          registry.register(spec, provider)
+        end
+
+        # Register a code generation capability
+        # @return [CapabilitySpecification] The registered capability
+        def register_code_generation
+          spec = CapabilitySpecification.new(
+            name: "code_generation",
+            description: "Generates code based on requirements",
+            version: "1.0.0",
+            inputs: {
+              requirements: {
+                type: "string",
+                required: true,
+                description: "The code requirements"
+              },
+              language: {
+                type: "string",
+                required: true,
+                description: "The programming language"
+              },
+              include_comments: {
+                type: "boolean",
+                description: "Whether to include comments in the code"
+              }
+            },
+            outputs: {
+              code: {
+                type: "string",
+                required: true,
+                description: "The generated code"
+              },
+              explanation: {
+                type: "string",
+                description: "Explanation of the code"
+              }
+            },
+            dependencies: [
+              {name: "text_generation", version: "1.0.0"}
+            ]
+          )
+
+          provider = CapabilityProvider.new(
+            capability: spec,
+            implementation: lambda do |inputs|
+              requirements = inputs[:requirements]
+              language = inputs[:language]
+              include_comments = inputs[:include_comments] || false
+
+              # Get the text generation capability
+              text_gen_provider = registry.get_provider("text_generation")
+
+              # Generate code
+              comments_instruction = include_comments ? "Include detailed comments." : "Keep comments minimal."
+              code_prompt = "Generate #{language} code for the following requirements:\n\n#{requirements}\n\n#{comments_instruction}"
+              code = text_gen_provider.execute(prompt: code_prompt)[:response]
+
+              # Generate explanation if needed
+              explanation = nil
+              if include_comments
+                explanation_prompt = "Explain the following #{language} code:\n\n#{code}"
+                explanation = text_gen_provider.execute(prompt: explanation_prompt)[:response]
+              end
+
+              result = {code: code}
+              result[:explanation] = explanation if explanation
+
+              result
+            end
+          )
+
+          registry.register(spec, provider)
+        end
+
+        # Register a summarization capability
+        # @return [CapabilitySpecification] The registered capability
+        def register_summarization
+          spec = CapabilitySpecification.new(
+            name: "summarization",
+            description: "Summarizes text content",
+            version: "1.0.0",
+            inputs: {
+              content: {
+                type: "string",
+                required: true,
+                description: "The content to summarize"
+              },
+              max_length: {
+                type: "integer",
+                description: "Maximum length of the summary"
+              },
+              format: {
+                type: "string",
+                description: "Format of the summary (paragraph, bullets, etc.)"
+              }
+            },
+            outputs: {
+              summary: {
+                type: "string",
+                required: true,
+                description: "The generated summary"
+              },
+              key_points: {
+                type: "array",
+                description: "Key points from the content"
+              }
+            },
+            dependencies: [
+              {name: "text_generation", version: "1.0.0"}
+            ]
+          )
+
+          provider = CapabilityProvider.new(
+            capability: spec,
+            implementation: lambda do |inputs|
+              content = inputs[:content]
+              max_length = inputs[:max_length]
+              format = inputs[:format] || "paragraph"
+
+              # Get the text generation capability
+              text_gen_provider = registry.get_provider("text_generation")
+
+              # Generate summary
+              length_instruction = max_length ? "Keep the summary under #{max_length} words." : ""
+              summary_prompt = "Summarize the following content in #{format} format. #{length_instruction}\n\n#{content}"
+              summary = text_gen_provider.execute(prompt: summary_prompt)[:response]
+
+              # Extract key points
+              key_points_prompt = "Extract 3-5 key points from the following content:\n\n#{content}"
+              key_points_response = text_gen_provider.execute(prompt: key_points_prompt)[:response]
+              key_points = key_points_response.split("\n").map(&:strip).reject(&:empty?)
+
+              {
+                summary: summary,
+                key_points: key_points
+              }
+            end
+          )
+
+          registry.register(spec, provider)
+        end
+
+        # Register a brainstorming capability
+        # @return [CapabilitySpecification] The registered capability
+        def register_brainstorming
+          spec = CapabilitySpecification.new(
+            name: "brainstorming",
+            description: "Generates creative ideas for a topic",
+            version: "1.0.0",
+            inputs: {
+              topic: {
+                type: "string",
+                required: true,
+                description: "The topic to brainstorm about"
+              },
+              num_ideas: {
+                type: "integer",
+                description: "Number of ideas to generate"
+              },
+              creativity: {
+                type: "number",
+                description: "Creativity level (0.0-1.0)"
+              }
+            },
+            outputs: {
+              ideas: {
+                type: "array",
+                required: true,
+                description: "The generated ideas"
+              },
+              themes: {
+                type: "array",
+                description: "Common themes across the ideas"
+              }
+            },
+            dependencies: [
+              {name: "text_generation", version: "1.0.0"}
+            ]
+          )
+
+          provider = CapabilityProvider.new(
+            capability: spec,
+            implementation: lambda do |inputs|
+              topic = inputs[:topic]
+              num_ideas = inputs[:num_ideas] || 10
+              creativity = inputs[:creativity] || 0.7
+
+              # Get the text generation capability
+              text_gen_provider = registry.get_provider("text_generation")
+
+              # Generate ideas
+              ideas_prompt = "Brainstorm #{num_ideas} creative ideas about: #{topic}"
+              ideas_response = text_gen_provider.execute(
+                prompt: ideas_prompt,
+                temperature: creativity
+              )[:response]
+
+              # Parse ideas
+              ideas = ideas_response.split("\n").map { |line| line.sub(/^\d+\.\s*/, "") }.map(&:strip).reject(&:empty?)
+
+              # Identify themes
+              themes_prompt = "Identify 3-5 common themes in the following ideas:\n\n#{ideas.join("\n")}"
+              themes_response = text_gen_provider.execute(prompt: themes_prompt)[:response]
+              themes = themes_response.split("\n").map(&:strip).reject(&:empty?)
+
+              {
+                ideas: ideas,
+                themes: themes
+              }
+            end
+          )
+
+          registry.register(spec, provider)
+        end
+
+        # Register a structured extraction capability
+        # @return [CapabilitySpecification] The registered capability
+        def register_structured_extraction
+          spec = CapabilitySpecification.new(
+            name: "structured_extraction",
+            description: "Extracts structured data from text",
+            version: "1.0.0",
+            inputs: {
+              content: {
+                type: "string",
+                required: true,
+                description: "The content to extract from"
+              },
+              schema: {
+                type: "object",
+                required: true,
+                description: "The schema to extract"
+              }
+            },
+            outputs: {
+              data: {
+                type: "object",
+                required: true,
+                description: "The extracted data"
+              },
+              confidence: {
+                type: "number",
+                description: "Confidence score for the extraction"
+              }
+            },
+            dependencies: [
+              {name: "text_generation", version: "1.0.0"}
+            ]
+          )
+
+          provider = CapabilityProvider.new(
+            capability: spec,
+            implementation: lambda do |inputs|
+              content = inputs[:content]
+              schema = inputs[:schema]
+
+              # Get the text generation capability
+              text_gen_provider = registry.get_provider("text_generation")
+
+              # Create extraction prompt
+              schema_str = JSON.pretty_generate(schema)
+              extraction_prompt = <<-PROMPT
+              Extract structured data from the following content according to this schema:
+              
+              #{schema_str}
+              
+              Content:
+              #{content}
+              
+              Return the data as valid JSON.
+              PROMPT
+
+              # Generate extraction
+              extraction_response = text_gen_provider.execute(prompt: extraction_prompt)[:response]
+
+              # Parse JSON (with error handling)
+              data = nil
+              begin
+                # Clean the response to ensure it's valid JSON
+                json_str = extraction_response.gsub(/```json|```/, "").strip
+                data = JSON.parse(json_str)
+              rescue JSON::ParserError
+                # Fallback extraction for malformed JSON
+                data = extract_fallback(extraction_response)
+              end
+
+              # Calculate confidence based on schema match
+              confidence = calculate_confidence(data, schema)
+
+              {
+                data: data,
+                confidence: confidence
+              }
+            end
+          )
+
+          registry.register(spec, provider)
+        end
+
+        private
+
+        def registry
+          AgentCapabilityRegistry.instance
+        end
+
+        # Fallback extraction for malformed JSON
+        def extract_fallback(text)
+          result = {}
+
+          # Try to extract key-value pairs
+          text.scan(/["']?([^"':]+)["']?\s*:\s*["']?([^"',}]+)["']?/) do |key, value|
+            result[key.strip] = value.strip
+          end
+
+          result
+        end
+
+        # Calculate confidence based on schema match
+        def calculate_confidence(data, schema)
+          return 0.0 if data.nil?
+
+          # Count matching fields
+          matches = 0
+          total = 0
+
+          schema.each do |key, _|
+            total += 1
+            matches += 1 if data.key?(key.to_s) || data.key?(key.to_sym)
+          end
+
+          (total > 0) ? matches.to_f / total : 0.0
+        end
+      end
+    end
+  end
+end

data/lib/agentic/capabilities.rb

@@ -0,0 +1,14 @@
+# frozen_string_literal: true
+
+require_relative "capabilities/examples"
+
+module Agentic
+  # Namespace for capability-related functionality
+  module Capabilities
+    # Register standard capabilities
+    # @return [void]
+    def self.register_standard_capabilities
+      Examples.register_all
+    end
+  end
+end

data/lib/agentic/capability_provider.rb

@@ -0,0 +1,146 @@
+# frozen_string_literal: true
+
+module Agentic
+  # Provider for a capability implementation
+  # @attr_reader [CapabilitySpecification] capability The capability specification
+  # @attr_reader [Proc, Class] implementation The implementation of the capability
+  class CapabilityProvider
+    attr_reader :capability, :implementation
+
+    # Initialize a new capability provider
+    # @param capability [CapabilitySpecification] The capability specification
+    # @param implementation [Proc, Class] The implementation of the capability
+    def initialize(capability:, implementation:)
+      @capability = capability
+      @implementation = implementation
+    end
+
+    # Execute the capability
+    # @param inputs [Hash] The inputs for the capability
+    # @return [Hash] The outputs from the capability
+    def execute(inputs = {})
+      # Validate inputs against capability specification
+      validate_inputs!(inputs)
+
+      # Execute the implementation
+      result = case @implementation
+      when Proc
+        @implementation.call(inputs)
+      when Class
+        instance = @implementation.new
+        instance.execute(inputs)
+      else
+        raise "Invalid implementation type: #{@implementation.class}"
+      end
+
+      # Validate outputs against capability specification
+      validate_outputs!(result)
+
+      result
+    end
+
+    private
+
+    def validate_inputs!(inputs)
+      # Skip validation if there are no input specifications
+      return unless @capability.inputs && !@capability.inputs.empty?
+
+      # Check for required inputs
+      @capability.inputs.each do |name, spec|
+        if spec[:required] && !inputs.key?(name.to_sym) && !inputs.key?(name.to_s)
+          raise "Missing required input: #{name}"
+        end
+      end
+
+      # Validate input types (if specified)
+      inputs.each do |name, value|
+        name_sym = name.to_sym
+        name_str = name.to_s
+
+        # Skip inputs that aren't in the specification
+        next unless @capability.inputs.key?(name_sym) || @capability.inputs.key?(name_str)
+
+        # Get the spec for this input
+        input_spec = @capability.inputs[name_sym] || @capability.inputs[name_str]
+
+        # Skip if no type is specified
+        next unless input_spec[:type]
+
+        # Check type
+        case input_spec[:type]
+        when "string"
+          unless value.is_a?(String)
+            raise "Input #{name} must be a string"
+          end
+        when "number", "integer"
+          unless value.is_a?(Numeric)
+            raise "Input #{name} must be a number"
+          end
+        when "boolean"
+          unless value == true || value == false
+            raise "Input #{name} must be a boolean"
+          end
+        when "array"
+          unless value.is_a?(Array)
+            raise "Input #{name} must be an array"
+          end
+        when "object", "hash"
+          unless value.is_a?(Hash)
+            raise "Input #{name} must be an object/hash"
+          end
+        end
+      end
+    end
+
+    def validate_outputs!(outputs)
+      # Skip validation if there are no output specifications or the output is nil
+      return unless @capability.outputs && !@capability.outputs.empty? && outputs
+
+      # Check for required outputs
+      @capability.outputs.each do |name, spec|
+        if spec[:required] && !outputs.key?(name.to_sym) && !outputs.key?(name.to_s)
+          raise "Missing required output: #{name}"
+        end
+      end
+
+      # Validate output types (if specified)
+      outputs.each do |name, value|
+        name_sym = name.to_sym
+        name_str = name.to_s
+
+        # Skip outputs that aren't in the specification
+        next unless @capability.outputs.key?(name_sym) || @capability.outputs.key?(name_str)
+
+        # Get the spec for this output
+        output_spec = @capability.outputs[name_sym] || @capability.outputs[name_str]
+
+        # Skip if no type is specified
+        next unless output_spec[:type]
+
+        # Check type
+        case output_spec[:type]
+        when "string"
+          unless value.is_a?(String)
+            raise "Output #{name} must be a string"
+          end
+        when "number", "integer"
+          unless value.is_a?(Numeric)
+            raise "Output #{name} must be a number"
+          end
+        when "boolean"
+          unless value == true || value == false
+            raise "Output #{name} must be a boolean"
+          end
+        when "array"
+          unless value.is_a?(Array)
+            raise "Output #{name} must be an array"
+          end
+        when "object", "hash"
+          unless value.is_a?(Hash)
+            raise "Output #{name} must be an object/hash"
+          end
+        end
+      end
+    end
+  end
+end