solid_agent 0.0.0 → 0.2.0

data/lib/solid_agent/agent_manifest/exporters/base_exporter.rb

@@ -0,0 +1,152 @@
+# frozen_string_literal: true
+
+module SolidAgent
+  module AgentManifest
+    module Exporters
+      # BaseExporter provides common functionality for all format exporters.
+      #
+      # Subclasses should implement:
+      # - .export(manifest, **options) - Convert manifest to string
+      # - .format_name - Return the format identifier symbol
+      #
+      class BaseExporter
+        class << self
+          # Export a manifest to string format
+          #
+          # @param manifest [Manifest] The manifest to export
+          # @param options [Hash] Format-specific options
+          # @return [String] Exported content
+          def export(manifest, **options)
+            raise NotImplementedError, "#{self}.export must be implemented by subclass"
+          end
+
+          # Get the format name for this exporter
+          #
+          # @return [Symbol]
+          def format_name
+            raise NotImplementedError, "#{self}.format_name must be implemented by subclass"
+          end
+
+          protected
+
+          # Build YAML frontmatter from a hash
+          #
+          # @param data [Hash] Frontmatter data
+          # @return [String] YAML frontmatter block
+          def build_frontmatter(data)
+            # Remove nil values and empty hashes/arrays
+            clean_data = deep_compact(data)
+            return "" if clean_data.empty?
+
+            yaml_content = clean_data.to_yaml
+            # Remove the leading "---\n" that to_yaml adds
+            yaml_content = yaml_content.sub(/\A---\n/, "")
+
+            "---\n#{yaml_content}---\n"
+          end
+
+          # Deep compact - remove nil values and empty collections recursively
+          #
+          # @param obj [Object] Object to compact
+          # @return [Object] Compacted object
+          def deep_compact(obj)
+            case obj
+            when Hash
+              result = {}
+              obj.each do |k, v|
+                compacted = deep_compact(v)
+                result[k] = compacted unless empty_value?(compacted)
+              end
+              result
+            when Array
+              obj.map { |v| deep_compact(v) }.reject { |v| empty_value?(v) }
+            else
+              obj
+            end
+          end
+
+          # Check if a value should be considered empty
+          #
+          # @param value [Object]
+          # @return [Boolean]
+          def empty_value?(value)
+            case value
+            when nil then true
+            when Hash then value.empty?
+            when Array then value.empty?
+            when String then value.empty?
+            else false
+            end
+          end
+
+          # Convert tools to exportable format
+          #
+          # @param tools [Array<Tool>] Tools to convert
+          # @return [Array<Hash>] Exportable tool data
+          def export_tools(tools)
+            return nil if tools.nil? || tools.empty?
+
+            tools.map do |tool|
+              if tool.reference?
+                { "$ref" => tool.ref }
+              else
+                {
+                  "name" => tool.name,
+                  "description" => tool.description,
+                  "inputSchema" => tool.input_schema
+                }.compact
+              end
+            end
+          end
+
+          # Convert resources to exportable format
+          #
+          # @param resources [Array<Resource>] Resources to convert
+          # @return [Array<Hash>] Exportable resource data
+          def export_resources(resources)
+            return nil if resources.nil? || resources.empty?
+
+            resources.map do |resource|
+              {
+                "name" => resource.name,
+                "description" => resource.description,
+                "uri" => resource.uri,
+                "mimeType" => resource.mime_type
+              }.compact
+            end
+          end
+
+          # Convert input schema to exportable format
+          #
+          # @param schema [InputSchema, nil] Schema to convert
+          # @return [Hash, nil] Exportable schema data
+          def export_input_schema(schema)
+            return nil unless schema
+
+            { "schema" => schema.schema }
+          end
+
+          # Strip provider prefix from model identifier
+          #
+          # @param model [String, nil] Full model identifier
+          # @return [String, nil] Model name without provider
+          def strip_provider(model)
+            return nil unless model
+            model.to_s.split("/").last
+          end
+
+          # Wrap text at specified width
+          #
+          # @param text [String] Text to wrap
+          # @param width [Integer] Maximum line width
+          # @return [String] Wrapped text
+          def word_wrap(text, width: 80)
+            return text unless text
+
+            text.gsub(/(.{1,#{width}})(\s+|$)/, "\\1\n").strip
+          end
+        end
+      end
+    end
+  end
+end

data/lib/solid_agent/agent_manifest/exporters/crewai_exporter.rb

@@ -0,0 +1,125 @@
+# frozen_string_literal: true
+
+module SolidAgent
+  module AgentManifest
+    module Exporters
+      # CrewAIExporter converts Manifests to CrewAI's agents.yaml format.
+      #
+      # @see https://docs.crewai.com
+      #
+      # @example Export a single manifest
+      #   content = CrewAIExporter.export(manifest)
+      #
+      # @example Export multiple manifests
+      #   content = CrewAIExporter.export_multiple([manifest1, manifest2])
+      #
+      class CrewAIExporter < BaseExporter
+        class << self
+          def format_name
+            :crewai
+          end
+
+          # Export manifest to CrewAI agents.yaml format
+          #
+          # @param manifest [Manifest] The manifest to export
+          # @return [String] Exported YAML content
+          def export(manifest, **)
+            export_multiple([manifest])
+          end
+
+          # Export multiple manifests to a single agents.yaml
+          #
+          # @param manifests [Array<Manifest>] Manifests to export
+          # @return [String] Exported YAML content
+          def export_multiple(manifests)
+            agents = {}
+
+            manifests.each do |manifest|
+              agent_key = manifest.name.to_s.tr("-", "_")
+              agents[agent_key] = build_crewai_agent(manifest)
+            end
+
+            # Use YAML dump with custom options for better formatting
+            yaml = agents.to_yaml
+            # Remove leading ---
+            yaml.sub(/\A---\n/, "")
+          end
+
+          private
+
+          def build_crewai_agent(manifest)
+            agent = {}
+
+            # Extract from CrewAI extensions if present
+            crewai_ext = manifest.extensions&.dig(:crewai) || {}
+
+            # Role - from extension or generate from name
+            agent["role"] = crewai_ext[:role] || crewai_ext["role"] ||
+              manifest.name.to_s.tr("-", " ").split.map(&:capitalize).join(" ")
+
+            # Goal - from extension or description
+            agent["goal"] = crewai_ext[:goal] || crewai_ext["goal"] || manifest.description
+
+            # Backstory - from extension or instructions
+            backstory = crewai_ext[:backstory] || crewai_ext["backstory"]
+            if backstory.blank? && manifest.instructions.present?
+              # Extract backstory from instructions if it follows the Role/Goal/Backstory format
+              backstory = extract_backstory(manifest.instructions)
+            end
+            agent["backstory"] = backstory if backstory.present?
+
+            # LLM - strip provider prefix for CrewAI
+            agent["llm"] = strip_provider(manifest.model) if manifest.model.present?
+
+            # Tools - CrewAI uses Python class names
+            if manifest.tools&.any?
+              agent["tools"] = manifest.tools.map do |tool|
+                if tool.reference?
+                  # Extract tool name from reference
+                  tool.ref.to_s.split("://").last.split("/").last
+                else
+                  # Convert to PascalCase tool class name
+                  tool.name.to_s.split(/[-_]/).map(&:capitalize).join + "Tool"
+                end
+              end
+            end
+
+            # CrewAI-specific options from extensions
+            %w[verbose allow_delegation max_iter max_rpm memory cache].each do |key|
+              value = crewai_ext[key.to_sym] || crewai_ext[key]
+              agent[key] = value unless value.nil?
+            end
+
+            # Config options
+            if manifest.config&.any?
+              agent["temperature"] = manifest.config[:temperature] || manifest.config["temperature"]
+              agent["max_tokens"] = manifest.config[:max_tokens] || manifest.config["max_tokens"]
+            end
+
+            agent.compact
+          end
+
+          # Extract backstory from instructions that follow Role/Goal/Backstory format
+          def extract_backstory(instructions)
+            return nil unless instructions
+
+            # Look for content after "Backstory:" or similar patterns
+            if instructions =~ /backstory:?\s*(.+?)(?:\n\n|\z)/mi
+              return ::Regexp.last_match(1).strip
+            end
+
+            # If instructions don't have Role/Goal prefix, use the whole thing as backstory
+            unless instructions =~ /\A\s*(Role:|Goal:)/i
+              return instructions
+            end
+
+            nil
+          end
+        end
+      end
+
+      # Register the exporter
+      ExporterRegistry.register(:crewai, CrewAIExporter)
+    end
+  end
+end

data/lib/solid_agent/agent_manifest/exporters/dotprompt_exporter.rb

@@ -0,0 +1,92 @@
+# frozen_string_literal: true
+
+module SolidAgent
+  module AgentManifest
+    module Exporters
+      # DotpromptExporter converts Manifests to Google Genkit's .prompt format.
+      #
+      # @see https://github.com/google/dotprompt
+      #
+      # @example Export a manifest
+      #   content = DotpromptExporter.export(manifest)
+      #
+      class DotpromptExporter < BaseExporter
+        class << self
+          def format_name
+            :dotprompt
+          end
+
+          # Export manifest to .prompt format
+          #
+          # @param manifest [Manifest] The manifest to export
+          # @param use_picoschema [Boolean] Export input schema as Picoschema
+          # @return [String] Exported content
+          def export(manifest, use_picoschema: true, **)
+            frontmatter = build_dotprompt_frontmatter(manifest, use_picoschema)
+            body = manifest.template || manifest.instructions || ""
+
+            "#{frontmatter}\n#{body.strip}\n"
+          end
+
+          private
+
+          def build_dotprompt_frontmatter(manifest, use_picoschema)
+            data = {}
+
+            # Basic fields
+            data["name"] = manifest.name if manifest.name.present?
+            data["model"] = manifest.model
+            data["description"] = manifest.description
+
+            # Config fields - Dotprompt uses camelCase
+            if manifest.config&.any?
+              data["temperature"] = manifest.config[:temperature] || manifest.config["temperature"]
+              data["maxOutputTokens"] = manifest.config[:max_tokens] || manifest.config["max_tokens"]
+              data["topP"] = manifest.config[:top_p] || manifest.config["top_p"]
+              data["topK"] = manifest.config[:top_k] || manifest.config["top_k"]
+              data["stopSequences"] = manifest.config[:stop] || manifest.config["stop"]
+            end
+
+            # Input schema
+            if manifest.input_schema
+              input_data = {}
+              if use_picoschema
+                input_data["schema"] = manifest.input_schema.to_picoschema
+              else
+                input_data["schema"] = manifest.input_schema.to_json_schema
+              end
+              data["input"] = input_data
+            end
+
+            # Output schema
+            if manifest.output_schema
+              data["output"] = manifest.output_schema
+            end
+
+            # Tools - Dotprompt format
+            if manifest.tools&.any?
+              data["tools"] = manifest.tools.map do |tool|
+                if tool.reference?
+                  tool.ref
+                else
+                  tool.name
+                end
+              end
+            end
+
+            # Preserve dotprompt-specific extensions
+            dotprompt_ext = manifest.extensions&.dig(:dotprompt) || {}
+            %w[candidates cache default variant metadata].each do |key|
+              data[key] = dotprompt_ext[key] if dotprompt_ext[key].present?
+            end
+
+            build_frontmatter(data)
+          end
+        end
+      end
+
+      # Register the exporter
+      ExporterRegistry.register(:dotprompt, DotpromptExporter)
+    end
+  end
+end

data/lib/solid_agent/agent_manifest/input_schema.rb

@@ -0,0 +1,154 @@
+# frozen_string_literal: true
+
+module SolidAgent
+  module AgentManifest
+    # InputSchema wraps a schema definition, supporting both Picoschema
+    # (compact YAML format) and JSON Schema formats.
+    #
+    # Provides bidirectional conversion between formats for interoperability.
+    #
+    # @example Picoschema format
+    #   schema = InputSchema.new(
+    #     schema: {
+    #       "query" => "string, the search query",
+    #       "limit?" => "integer, max results"
+    #     },
+    #     format: :picoschema
+    #   )
+    #   schema.to_json_schema  # => JSON Schema object
+    #
+    # @example JSON Schema format
+    #   schema = InputSchema.new(
+    #     schema: {
+    #       "type" => "object",
+    #       "properties" => { "query" => { "type" => "string" } }
+    #     },
+    #     format: :json_schema
+    #   )
+    #   schema.to_picoschema  # => Picoschema object
+    #
+    class InputSchema
+      # @return [Hash] The schema definition
+      attr_accessor :schema
+
+      # @return [Symbol] Schema format (:picoschema or :json_schema)
+      attr_accessor :format
+
+      def initialize(schema:, format: :picoschema)
+        @schema = schema
+        @format = format.to_sym
+      end
+
+      # Convert schema to JSON Schema format
+      #
+      # @return [Hash] JSON Schema object
+      def to_json_schema
+        case format
+        when :picoschema
+          Picoschema.to_json_schema(schema)
+        when :json_schema
+          schema
+        else
+          raise SchemaError, "Unknown schema format: #{format}"
+        end
+      end
+
+      # Convert schema to Picoschema format
+      #
+      # @return [Hash] Picoschema object
+      def to_picoschema
+        case format
+        when :picoschema
+          schema
+        when :json_schema
+          Picoschema.from_json_schema(schema)
+        else
+          raise SchemaError, "Unknown schema format: #{format}"
+        end
+      end
+
+      # Convert to hash representation
+      #
+      # @return [Hash]
+      def to_h
+        {
+          schema: schema,
+          format: format
+        }
+      end
+
+      # Validate input data against this schema
+      #
+      # Requires the json_schemer gem for validation.
+      #
+      # @param input_hash [Hash] Input data to validate
+      # @return [Array<String>] List of validation errors (empty if valid)
+      def validate_input(input_hash)
+        return [] unless defined?(JSONSchemer)
+
+        json_schema = to_json_schema
+        schemer = JSONSchemer.schema(json_schema)
+        schemer.validate(input_hash).map { |error| error["error"] }
+      rescue => e
+        ["Schema validation error: #{e.message}"]
+      end
+
+      # Check if input is valid against schema
+      #
+      # @param input_hash [Hash] Input data to validate
+      # @return [Boolean]
+      def valid_input?(input_hash)
+        validate_input(input_hash).empty?
+      end
+
+      # Get list of required field names
+      #
+      # @return [Array<String>]
+      def required_fields
+        json = to_json_schema
+        json["required"] || []
+      end
+
+      # Get all field names
+      #
+      # @return [Array<String>]
+      def field_names
+        json = to_json_schema
+        (json["properties"] || {}).keys
+      end
+
+      # Get field definition
+      #
+      # @param field_name [String] Name of the field
+      # @return [Hash, nil] Field schema definition
+      def field(field_name)
+        json = to_json_schema
+        json.dig("properties", field_name.to_s)
+      end
+
+      # Create from various input formats
+      #
+      # @param data [Hash] Schema data
+      # @return [InputSchema]
+      def self.from_hash(data)
+        schema = data["schema"] || data[:schema]
+        format = data["format"] || data[:format] || detect_format(schema)
+
+        new(schema: schema, format: format)
+      end
+
+      # Detect schema format from content
+      #
+      # @param schema [Hash] Schema to analyze
+      # @return [Symbol] Detected format
+      def self.detect_format(schema)
+        return :json_schema if schema.nil?
+        return :json_schema if schema["type"].present?
+        return :json_schema if schema["properties"].present?
+        return :json_schema if schema["$schema"].present?
+
+        :picoschema
+      end
+    end
+  end
+end