solid_agent 0.0.0 → 0.2.0

data/lib/solid_agent/agent_manifest/parsers/base_parser.rb

@@ -0,0 +1,223 @@
+# frozen_string_literal: true
+
+module SolidAgent
+  module AgentManifest
+    module Parsers
+      # BaseParser provides common functionality for all format parsers.
+      #
+      # Subclasses should implement:
+      # - .parse_string(content) - Parse content string into a Manifest
+      # - .format_name - Return the format identifier symbol
+      #
+      class BaseParser
+        FRONTMATTER_REGEX = /\A---\s*\n(.*?)\n---\s*\n(.*)\z/m
+
+        class << self
+          # Parse a file into a Manifest
+          #
+          # @param path [String] Path to the file
+          # @return [Manifest] Parsed manifest
+          def parse(path)
+            content = File.read(path, encoding: "UTF-8")
+            manifest = parse_string(content)
+
+            # Handle array results (e.g., CrewAI with multiple agents)
+            if manifest.is_a?(Array)
+              manifest.each do |m|
+                m.source_path = path
+                m.source_format = format_name
+              end
+            else
+              manifest.source_path = path
+              manifest.source_format = format_name
+            end
+
+            manifest
+          end
+
+          # Parse content string into a Manifest
+          #
+          # @param content [String] File content
+          # @return [Manifest] Parsed manifest
+          def parse_string(content)
+            raise NotImplementedError, "#{self}.parse_string must be implemented by subclass"
+          end
+
+          # Get the format name for this parser
+          #
+          # @return [Symbol]
+          def format_name
+            raise NotImplementedError, "#{self}.format_name must be implemented by subclass"
+          end
+
+          protected
+
+          # Extract YAML frontmatter from markdown content
+          #
+          # @param content [String] Full content with frontmatter
+          # @return [Array<Hash, String>] [frontmatter_hash, body]
+          def extract_frontmatter(content)
+            return [{}, content.strip] if content.blank?
+
+            match = content.match(FRONTMATTER_REGEX)
+
+            unless match
+              # Check if frontmatter was intended but malformed
+              if content.strip.start_with?("---")
+                raise ParseError, "Malformed frontmatter: missing closing '---' delimiter"
+              end
+              return [{}, content.strip]
+            end
+
+            begin
+              frontmatter = YAML.safe_load(
+                match[1],
+                permitted_classes: [Symbol, Date, Time],
+                permitted_symbols: [],
+                aliases: false
+              )
+            rescue Psych::SyntaxError => e
+              raise ParseError, "Invalid YAML in frontmatter: #{e.message}"
+            end
+
+            [frontmatter || {}, match[2].strip]
+          end
+
+          # Normalize model identifier to provider/model format
+          #
+          # @param model_string [String, nil] Model identifier
+          # @return [String, nil] Normalized model identifier
+          def normalize_model(model_string)
+            return nil unless model_string.present?
+
+            model_string = model_string.to_s.strip
+
+            # Already in provider/model format
+            return model_string if model_string.include?("/")
+
+            # Detect provider from model name
+            if model_string.start_with?("gpt-") || model_string.start_with?("o1") || model_string.start_with?("o3")
+              "openai/#{model_string}"
+            elsif model_string.start_with?("claude-")
+              "anthropic/#{model_string}"
+            elsif model_string.start_with?("gemini-")
+              "google/#{model_string}"
+            elsif model_string.start_with?("llama") || model_string.start_with?("mixtral")
+              "meta/#{model_string}"
+            else
+              # Unknown - return as-is
+              model_string
+            end
+          end
+
+          # Parse tools array from frontmatter data
+          #
+          # @param tools_data [Array, nil] Tools data from frontmatter
+          # @return [Array<Tool>] Parsed tools
+          def parse_tools(tools_data)
+            return [] unless tools_data.is_a?(Array)
+
+            tools_data.map do |tool_data|
+              if tool_data.is_a?(String)
+                # String reference
+                Tool.new(ref: tool_data)
+              elsif tool_data["$ref"]
+                # Explicit reference
+                Tool.new(ref: tool_data["$ref"])
+              else
+                # Inline definition
+                Tool.from_hash(tool_data)
+              end
+            end
+          end
+
+          # Parse resources array from frontmatter data
+          #
+          # @param resources_data [Array, nil] Resources data from frontmatter
+          # @return [Array<Resource>] Parsed resources
+          def parse_resources(resources_data)
+            return [] unless resources_data.is_a?(Array)
+
+            resources_data.map { |data| Resource.from_hash(data) }
+          end
+
+          # Parse input schema from frontmatter data
+          #
+          # @param input_data [Hash, nil] Input schema data
+          # @return [InputSchema, nil] Parsed input schema
+          def parse_input_schema(input_data)
+            return nil unless input_data.is_a?(Hash)
+
+            schema = input_data["schema"] || input_data[:schema]
+            return nil unless schema
+
+            format = InputSchema.detect_format(schema)
+            InputSchema.new(schema: schema, format: format)
+          end
+
+          # Extract framework extensions from frontmatter
+          #
+          # @param frontmatter [Hash] Full frontmatter hash
+          # @return [Hash] Framework extensions
+          def extract_extensions(frontmatter)
+            extensions = {}
+
+            %w[activeagent crewai langchain genkit dotprompt].each do |framework|
+              value = frontmatter[framework] || frontmatter[framework.to_sym]
+              extensions[framework.to_sym] = value if value.present?
+            end
+
+            extensions
+          end
+
+          # Extract instructions from markdown body
+          #
+          # @param body [String] Markdown body
+          # @return [String, nil] Extracted instructions
+          def extract_instructions(body)
+            return nil if body.blank?
+
+            # Try to find ## Instructions section
+            if body =~ /##\s*Instructions\s*\n(.*?)(?=\n##|\z)/mi
+              return ::Regexp.last_match(1).strip
+            end
+
+            # Try ## Instruct (abbreviated)
+            if body =~ /##\s*Instruct\w*\s*\n(.*?)(?=\n##|\z)/mi
+              return ::Regexp.last_match(1).strip
+            end
+
+            # Fall back to body without title
+            body.gsub(/\A#\s+[^\n]+\n+/, "").strip.presence
+          end
+
+          # Parse config/model parameters
+          #
+          # @param frontmatter [Hash] Frontmatter hash
+          # @return [Hash] Config hash
+          def parse_config(frontmatter)
+            config = frontmatter["config"] || frontmatter[:config] || {}
+
+            # Also check for top-level config keys (Dotprompt style)
+            %w[temperature max_tokens maxOutputTokens top_p topP top_k topK stop stopSequences].each do |key|
+              value = frontmatter[key] || frontmatter[key.to_sym]
+              if value.present?
+                # Normalize key names
+                normalized_key = case key
+                when "maxOutputTokens" then "max_tokens"
+                when "topP" then "top_p"
+                when "topK" then "top_k"
+                when "stopSequences" then "stop"
+                else key
+                end
+                config[normalized_key] = value
+              end
+            end
+
+            config.presence || {}
+          end
+        end
+      end
+    end
+  end
+end

data/lib/solid_agent/agent_manifest/parsers/crewai_parser.rb

@@ -0,0 +1,201 @@
+# frozen_string_literal: true
+
+module SolidAgent
+  module AgentManifest
+    module Parsers
+      # CrewAIParser handles CrewAI's agents.yaml format.
+      #
+      # CrewAI defines agents with role, goal, and backstory.
+      # This parser converts them to the unified Manifest format.
+      #
+      # @see https://docs.crewai.com
+      #
+      # @example agents.yaml
+      #   research_analyst:
+      #     role: >
+      #       Senior Research Analyst
+      #     goal: >
+      #       Uncover cutting-edge developments
+      #     backstory: >
+      #       You're a seasoned researcher...
+      #     llm: claude-sonnet-4-20250514
+      #     tools:
+      #       - SerperDevTool
+      #
+      class CrewAIParser < BaseParser
+        class << self
+          def format_name
+            :crewai
+          end
+
+          def parse_string(content)
+            data = YAML.safe_load(content, permitted_classes: [Symbol])
+
+            raise ParseError, "Invalid CrewAI YAML: expected hash" unless data.is_a?(Hash)
+
+            # CrewAI files can contain multiple agents
+            agents = data.map do |agent_name, agent_data|
+              parse_agent(agent_name.to_s, agent_data)
+            end
+
+            # If single agent, return it directly; otherwise return array
+            agents.size == 1 ? agents.first : agents
+          end
+
+          # Parse a file containing multiple agents
+          #
+          # @param agents_path [String] Path to agents.yaml
+          # @param tasks_path [String, nil] Optional path to tasks.yaml
+          # @return [Array<Manifest>] Parsed manifests
+          def parse_with_tasks(agents_path, tasks_path = nil)
+            agents_content = File.read(agents_path, encoding: "UTF-8")
+            result = parse_string(agents_content)
+
+            # Ensure we have an array
+            manifests = result.is_a?(Array) ? result : [result]
+
+            # Optionally merge task information
+            if tasks_path && File.exist?(tasks_path)
+              tasks = YAML.safe_load(File.read(tasks_path, encoding: "UTF-8"))
+              merge_tasks(manifests, tasks)
+            end
+
+            manifests
+          end
+
+          private
+
+          def parse_agent(name, data)
+            return nil unless data.is_a?(Hash)
+
+            Manifest.new(
+              # Convert snake_case name to kebab-case
+              name: name.tr("_", "-"),
+              description: clean_multiline(data["goal"]),
+
+              # Model
+              model: normalize_model(data["llm"]),
+              config: parse_crewai_config(data),
+
+              # Build instructions from role + backstory
+              instructions: build_instructions(data),
+              template: build_template(data),
+
+              # Tools (as references to Python classes)
+              tools: parse_crewai_tools(data["tools"]),
+
+              # Preserve CrewAI-specific config
+              extensions: {
+                crewai: build_crewai_extensions(data)
+              }
+            )
+          end
+
+          # Parse CrewAI config options
+          def parse_crewai_config(data)
+            config = {}
+
+            # CrewAI doesn't have direct model config in YAML typically
+            # but some implementations support it
+            config[:temperature] = data["temperature"] if data["temperature"]
+            config[:max_tokens] = data["max_tokens"] if data["max_tokens"]
+
+            config.compact
+          end
+
+          # Build instructions from role and backstory
+          def build_instructions(data)
+            parts = []
+
+            role = clean_multiline(data["role"])
+            goal = clean_multiline(data["goal"])
+            backstory = clean_multiline(data["backstory"])
+
+            parts << "Role: #{role}" if role.present?
+            parts << "Goal: #{goal}" if goal.present?
+            parts << "\n#{backstory}" if backstory.present?
+
+            parts.join("\n").strip
+          end
+
+          # Build a markdown template from CrewAI data
+          def build_template(data)
+            role = clean_multiline(data["role"]) || "Agent"
+            goal = clean_multiline(data["goal"])
+            backstory = clean_multiline(data["backstory"])
+
+            template = "# #{role}\n\n"
+            template += "## Goal\n\n#{goal}\n\n" if goal
+            template += "## Backstory\n\n#{backstory}\n\n" if backstory
+            template
+          end
+
+          # Parse CrewAI tool references
+          def parse_crewai_tools(tools_data)
+            return [] unless tools_data.is_a?(Array)
+
+            tools_data.map do |tool|
+              if tool.is_a?(String)
+                # Reference to a Python tool class
+                Tool.new(ref: "crewai://#{tool}")
+              elsif tool.is_a?(Hash)
+                Tool.from_hash(tool)
+              else
+                nil
+              end
+            end.compact
+          end
+
+          # Build CrewAI-specific extensions
+          def build_crewai_extensions(data)
+            {
+              role: clean_multiline(data["role"]),
+              goal: clean_multiline(data["goal"]),
+              backstory: clean_multiline(data["backstory"]),
+              verbose: data["verbose"],
+              allow_delegation: data["allow_delegation"],
+              max_iter: data["max_iter"],
+              max_rpm: data["max_rpm"],
+              memory: data["memory"],
+              cache: data["cache"],
+              step_callback: data["step_callback"],
+              system_template: data["system_template"],
+              prompt_template: data["prompt_template"],
+              response_template: data["response_template"]
+            }.compact
+          end
+
+          # Clean up YAML multiline strings
+          def clean_multiline(value)
+            return nil unless value
+            value.to_s.strip.gsub(/\s+/, " ")
+          end
+
+          # Merge task information into manifests
+          def merge_tasks(manifests, tasks)
+            # Tasks in CrewAI are associated with agents
+            # This is a simplified merge - full implementation would be more complex
+            tasks.each do |task_name, task_data|
+              agent_name = task_data["agent"]&.tr("_", "-")
+              manifest = manifests.find { |m| m.name == agent_name }
+
+              if manifest
+                # Add task information to extensions
+                manifest.extensions[:crewai] ||= {}
+                manifest.extensions[:crewai][:tasks] ||= []
+                manifest.extensions[:crewai][:tasks] << {
+                  name: task_name,
+                  description: task_data["description"],
+                  expected_output: task_data["expected_output"]
+                }
+              end
+            end
+          end
+        end
+      end
+
+      # Register the parser
+      ParserRegistry.register(:crewai, CrewAIParser)
+    end
+  end
+end

data/lib/solid_agent/agent_manifest/parsers/dotprompt_parser.rb

@@ -0,0 +1,122 @@
+# frozen_string_literal: true
+
+module SolidAgent
+  module AgentManifest
+    module Parsers
+      # DotpromptParser handles Google Genkit's .prompt format.
+      #
+      # Dotprompt files use YAML frontmatter with Handlebars-style templates.
+      # This parser converts them to the unified Manifest format.
+      #
+      # @see https://github.com/google/dotprompt
+      #
+      # @example Basic .prompt file
+      #   ---
+      #   model: googleai/gemini-1.5-pro
+      #   input:
+      #     schema:
+      #       text: string
+      #   output:
+      #     format: json
+      #   ---
+      #
+      #   Extract information from: {{text}}
+      #
+      class DotpromptParser < BaseParser
+        class << self
+          def format_name
+            :dotprompt
+          end
+
+          def parse_string(content)
+            frontmatter, body = extract_frontmatter(content)
+
+            # Extract name from frontmatter or generate from content
+            name = frontmatter["name"] || generate_name_from_content(body)
+
+            Manifest.new(
+              name: name,
+              version: frontmatter["version"] || "1.0.0",
+              description: frontmatter["description"],
+
+              # Model - Dotprompt format
+              model: normalize_model(frontmatter["model"]),
+              config: parse_dotprompt_config(frontmatter),
+
+              # Schemas
+              input_schema: parse_input_schema(frontmatter["input"]),
+              output_schema: parse_output_schema(frontmatter["output"]),
+
+              # Tools (Dotprompt can reference tools)
+              tools: parse_tools(frontmatter["tools"]),
+
+              # Template
+              instructions: body,
+              template: body,
+
+              # Store original Dotprompt config in extensions
+              extensions: {
+                dotprompt: extract_dotprompt_extensions(frontmatter)
+              }
+            )
+          end
+
+          private
+
+          # Generate a name from template content
+          def generate_name_from_content(body)
+            # Try to extract from first line/heading
+            if body =~ /\A#\s+(.+)/
+              ::Regexp.last_match(1).strip.downcase.gsub(/\s+/, "-").gsub(/[^a-z0-9-]/, "")
+            else
+              "unnamed-prompt"
+            end
+          end
+
+          # Parse Dotprompt-specific config fields
+          def parse_dotprompt_config(frontmatter)
+            config = {}
+
+            # Map Dotprompt field names to normalized names
+            config[:temperature] = frontmatter["temperature"] if frontmatter["temperature"]
+            config[:max_tokens] = frontmatter["maxOutputTokens"] if frontmatter["maxOutputTokens"]
+            config[:top_p] = frontmatter["topP"] if frontmatter["topP"]
+            config[:top_k] = frontmatter["topK"] if frontmatter["topK"]
+            config[:stop] = frontmatter["stopSequences"] if frontmatter["stopSequences"]
+
+            # Also support normalized names
+            config[:temperature] ||= frontmatter["config"]&.dig("temperature")
+            config[:max_tokens] ||= frontmatter["config"]&.dig("max_tokens")
+
+            config.compact
+          end
+
+          # Parse Dotprompt output schema
+          def parse_output_schema(output_data)
+            return nil unless output_data.is_a?(Hash)
+
+            {
+              format: output_data["format"],
+              schema: output_data["schema"]
+            }.compact.presence
+          end
+
+          # Extract Dotprompt-specific extensions that don't map to standard fields
+          def extract_dotprompt_extensions(frontmatter)
+            extensions = {}
+
+            # Preserve Dotprompt-specific fields
+            %w[candidates cache default variant metadata].each do |key|
+              extensions[key] = frontmatter[key] if frontmatter[key].present?
+            end
+
+            extensions.presence
+          end
+        end
+      end
+
+      # Register the parser
+      ParserRegistry.register(:dotprompt, DotpromptParser)
+    end
+  end
+end

data/lib/solid_agent/agent_manifest/parsers/github_prompt_parser.rb

@@ -0,0 +1,143 @@
+# frozen_string_literal: true
+
+module SolidAgent
+  module AgentManifest
+    module Parsers
+      # GitHubPromptParser handles GitHub Copilot's .prompt.md format.
+      #
+      # GitHub Copilot prompt files use Markdown with YAML frontmatter,
+      # supporting variables, tool references, and agent configuration.
+      #
+      # @see https://docs.github.com/en/copilot/tutorials/customization-library/prompt-files
+      #
+      # @example .prompt.md file
+      #   ---
+      #   model: GPT-4o
+      #   tools: ['githubRepo', 'search/codebase']
+      #   description: 'Generate a new React form component'
+      #   ---
+      #
+      #   Create a React form component for ${input:formName}
+      #
+      class GitHubPromptParser < BaseParser
+        class << self
+          def format_name
+            :github_prompt
+          end
+
+          def parse_string(content)
+            frontmatter, body = extract_frontmatter(content)
+
+            Manifest.new(
+              name: extract_name(frontmatter, body),
+              description: frontmatter["description"],
+              version: "1.0.0",
+
+              # Model
+              model: normalize_github_model(frontmatter["model"]),
+              config: {},
+
+              # Tools are GitHub-specific references
+              tools: parse_github_tools(frontmatter["tools"]),
+
+              # Template with GitHub variable syntax
+              instructions: body,
+              template: body,
+
+              # Preserve GitHub-specific config
+              extensions: {
+                github_prompt: extract_github_extensions(frontmatter)
+              }
+            )
+          end
+
+          private
+
+          # Extract name from frontmatter or generate from content
+          def extract_name(frontmatter, body)
+            return frontmatter["name"] if frontmatter["name"].present?
+
+            # Try to extract from description
+            if frontmatter["description"].present?
+              return frontmatter["description"]
+                .downcase
+                .gsub(/[^a-z0-9\s-]/, "")
+                .gsub(/\s+/, "-")
+                .slice(0, 50)
+            end
+
+            # Try to extract from first heading
+            if body =~ /\A#\s+(.+)/
+              return ::Regexp.last_match(1)
+                .strip
+                .downcase
+                .gsub(/[^a-z0-9\s-]/, "")
+                .gsub(/\s+/, "-")
+            end
+
+            "github-prompt"
+          end
+
+          # Normalize GitHub model names
+          def normalize_github_model(model)
+            return nil unless model.present?
+
+            model_str = model.to_s.strip
+
+            # GitHub uses simplified model names
+            case model_str.downcase
+            when "gpt-4o", "gpt4o"
+              "openai/gpt-4o"
+            when "gpt-4", "gpt4"
+              "openai/gpt-4"
+            when "gpt-3.5-turbo", "gpt35turbo"
+              "openai/gpt-3.5-turbo"
+            when /\Aclaude/
+              "anthropic/#{model_str.downcase}"
+            else
+              normalize_model(model_str)
+            end
+          end
+
+          # Parse GitHub tool references
+          def parse_github_tools(tools_data)
+            return [] unless tools_data.is_a?(Array)
+
+            tools_data.map do |tool|
+              tool_name = tool.to_s
+              Tool.new(ref: "github://#{tool_name}")
+            end
+          end
+
+          # Extract GitHub-specific extensions
+          def extract_github_extensions(frontmatter)
+            {
+              agent: frontmatter["agent"],
+              mode: frontmatter["mode"],
+              variables: extract_variables(frontmatter),
+              # Preserve any other GitHub-specific fields
+              original_tools: frontmatter["tools"]
+            }.compact
+          end
+
+          # Extract variable definitions
+          def extract_variables(frontmatter)
+            variables = {}
+
+            # GitHub prompts can define input variables
+            frontmatter.each do |key, value|
+              next unless key.to_s.start_with?("input:")
+              var_name = key.to_s.sub("input:", "")
+              variables[var_name] = value
+            end
+
+            variables.presence
+          end
+        end
+      end
+
+      # Register the parser
+      ParserRegistry.register(:github_prompt, GitHubPromptParser)
+    end
+  end
+end