agentic 0.1.0 → 0.2.0

data/lib/agentic/capability_specification.rb

@@ -0,0 +1,118 @@
+# frozen_string_literal: true
+
+module Agentic
+  # Defines the specification for an agent capability
+  # @attr_reader [String] name The name of the capability
+  # @attr_reader [String] description Description of the capability
+  # @attr_reader [String] version The version of the capability
+  # @attr_reader [Hash] inputs The required inputs for the capability
+  # @attr_reader [Hash] outputs The expected outputs from the capability
+  # @attr_reader [Array<Hash>] dependencies The dependencies of the capability
+  class CapabilitySpecification
+    attr_reader :name, :description, :version, :inputs, :outputs, :dependencies
+
+    # Initialize a new capability specification
+    # @param name [String] The name of the capability
+    # @param description [String] Description of the capability
+    # @param version [String] The version of the capability
+    # @param inputs [Hash] The required inputs for the capability
+    # @param outputs [Hash] The expected outputs from the capability
+    # @param dependencies [Array<Hash>] The dependencies of the capability
+    def initialize(name:, description:, version:, inputs: {}, outputs: {}, dependencies: [])
+      @name = name
+      @description = description
+      @version = version
+      @inputs = inputs
+      @outputs = outputs
+      @dependencies = dependencies
+    end
+
+    # Check if this capability is compatible with another capability
+    # @param other [CapabilitySpecification] The other capability
+    # @return [Boolean] True if compatible
+    def compatible_with?(other)
+      return false unless other.is_a?(CapabilitySpecification)
+      return false unless name == other.name
+
+      # Compare versions using semantic versioning rules
+      # For now, just check for exact match or higher minor version
+      return true if version == other.version
+
+      begin
+        my_parts = version.split(".").map(&:to_i)
+        other_parts = other.version.split(".").map(&:to_i)
+
+        # Major version must match
+        return false unless my_parts[0] == other_parts[0]
+
+        # Our minor version should be >= other's minor version
+        my_parts[1] >= other_parts[1]
+      rescue
+        # If version parsing fails, require exact match
+        false
+      end
+    end
+
+    # Convert to a hash representation
+    # @return [Hash] The hash representation
+    def to_h
+      {
+        name: @name,
+        description: @description,
+        version: @version,
+        inputs: @inputs,
+        outputs: @outputs,
+        dependencies: @dependencies
+      }
+    end
+
+    # Create from a hash representation
+    # @param hash [Hash] The hash representation
+    # @return [CapabilitySpecification] The capability specification
+    def self.from_h(hash)
+      new(
+        name: hash[:name] || hash["name"],
+        description: hash[:description] || hash["description"],
+        version: hash[:version] || hash["version"],
+        inputs: hash[:inputs] || hash["inputs"] || {},
+        outputs: hash[:outputs] || hash["outputs"] || {},
+        dependencies: hash[:dependencies] || hash["dependencies"] || []
+      )
+    end
+
+    # Get the capability requirements as a human-readable string
+    # @return [String] The capability requirements
+    def requirements_description
+      result = "Capability: #{name} (v#{version})\n"
+      result += "Description: #{description}\n"
+
+      unless inputs.empty?
+        result += "\nInputs:\n"
+        inputs.each do |name, spec|
+          result += "  #{name}: #{spec[:type] || "any"}"
+          result += " (required)" if spec[:required]
+          result += " - #{spec[:description]}" if spec[:description]
+          result += "\n"
+        end
+      end
+
+      unless outputs.empty?
+        result += "\nOutputs:\n"
+        outputs.each do |name, spec|
+          result += "  #{name}: #{spec[:type] || "any"}"
+          result += " - #{spec[:description]}" if spec[:description]
+          result += "\n"
+        end
+      end
+
+      unless dependencies.empty?
+        result += "\nDependencies:\n"
+        dependencies.each do |dep|
+          result += "  #{dep[:name]} (v#{dep[:version] || "any"})\n"
+        end
+      end
+
+      result
+    end
+  end
+end

data/lib/agentic/cli/agent.rb

@@ -0,0 +1,31 @@
+# frozen_string_literal: true
+
+module Agentic
+  class CLI < Thor
+    # CLI commands for managing agents
+    class Agent < Thor
+      desc "list", "List available agents"
+      def list
+        puts "Available agents:"
+        # In a future implementation, this would list agents from a registry
+        puts "  - No custom agents registered yet"
+      end
+
+      desc "create NAME", "Create a new agent"
+      option :role, type: :string, required: true, desc: "Role of the agent"
+      option :instructions, type: :string, required: true, desc: "Instructions for the agent"
+      def create(name)
+        puts "Creating agent: #{name}"
+        # In a future implementation, this would create and register an agent
+        puts "Agent created successfully."
+      end
+
+      desc "delete NAME", "Delete an agent"
+      def delete(name)
+        puts "Deleting agent: #{name}"
+        # In a future implementation, this would delete an agent from a registry
+        puts "Agent deleted successfully."
+      end
+    end
+  end
+end

data/lib/agentic/cli/capabilities.rb

@@ -0,0 +1,191 @@
+# frozen_string_literal: true
+
+module Agentic
+  class CLI < Thor
+    # Command-line interface for managing capabilities
+    class Capabilities < Thor
+      desc "list", "List available capabilities"
+      option :detailed, type: :boolean, aliases: "-d",
+        desc: "Show detailed information"
+      def list
+        # Initialize agent assembly system
+        Agentic.initialize_agent_assembly
+        registry = Agentic.agent_capability_registry
+
+        capabilities = registry.list(include_providers: options[:detailed])
+
+        if capabilities.empty?
+          puts UI.box(
+            "Available Capabilities",
+            "No capabilities registered yet.\n\n" \
+            "You can register capabilities programmatically via Agentic.register_capability.",
+            padding: [1, 2, 1, 2],
+            style: {border: {fg: :blue}}
+          )
+          return
+        end
+
+        output = ""
+        capabilities.each do |name, info|
+          output += "#{UI.colorize(name, :blue)}:\n"
+          output += "  Available versions: #{info[:versions].join(", ")}\n"
+          output += "  Latest version: #{UI.colorize(info[:latest], :green)}\n"
+
+          if options[:detailed] && info[:providers]
+            # Get a capability to show more details
+            capability = registry.get(name, info[:latest])
+            if capability
+              output += "  Description: #{capability.description}\n"
+
+              unless capability.inputs.empty?
+                output += "  Inputs:\n"
+                capability.inputs.each do |input_name, input_spec|
+                  required = input_spec[:required] ? " (required)" : ""
+                  output += "    - #{input_name}#{required}: #{input_spec[:type] || "any"}\n"
+                  output += "      #{input_spec[:description]}\n" if input_spec[:description]
+                end
+              end
+
+              unless capability.outputs.empty?
+                output += "  Outputs:\n"
+                capability.outputs.each do |output_name, output_spec|
+                  output += "    - #{output_name}: #{output_spec[:type] || "any"}\n"
+                  output += "      #{output_spec[:description]}\n" if output_spec[:description]
+                end
+              end
+
+              unless capability.dependencies.empty?
+                output += "  Dependencies:\n"
+                capability.dependencies.each do |dep|
+                  output += "    - #{dep[:name]} (#{dep[:version] || "any version"})\n"
+                end
+              end
+            end
+          end
+
+          output += "\n"
+        end
+
+        puts UI.box(
+          "Available Capabilities",
+          output,
+          padding: [1, 2, 1, 2],
+          style: {border: {fg: :blue}}
+        )
+      end
+
+      desc "show NAME", "Show details of a specific capability"
+      option :version, type: :string, aliases: "-v",
+        desc: "Capability version (defaults to latest)"
+      def show(name)
+        # Initialize agent assembly system
+        Agentic.initialize_agent_assembly
+        registry = Agentic.agent_capability_registry
+
+        capability = registry.get(name, options[:version])
+
+        unless capability
+          available = registry.list.keys.join(", ")
+          available_text = available.empty? ? "No capabilities registered yet." : "Available: #{available}"
+
+          puts UI.box(
+            "Error",
+            "Capability '#{UI.colorize(name, :yellow)}' not found.\n\n#{available_text}",
+            padding: [1, 2, 1, 2],
+            style: {border: {fg: :red}}
+          )
+          exit 1
+        end
+
+        output = ""
+        output += "Name: #{UI.colorize(capability.name, :blue)}\n"
+        output += "Version: #{UI.colorize(capability.version, :green)}\n"
+        output += "Description: #{capability.description}\n\n"
+
+        unless capability.inputs.empty?
+          output += "Inputs:\n"
+          capability.inputs.each do |input_name, input_spec|
+            required = input_spec[:required] ? " (required)" : ""
+            output += "  - #{UI.colorize(input_name, :yellow)}#{required}: #{input_spec[:type] || "any"}\n"
+            output += "    #{input_spec[:description]}\n" if input_spec[:description]
+          end
+          output += "\n"
+        end
+
+        unless capability.outputs.empty?
+          output += "Outputs:\n"
+          capability.outputs.each do |output_name, output_spec|
+            output += "  - #{UI.colorize(output_name, :yellow)}: #{output_spec[:type] || "any"}\n"
+            output += "    #{output_spec[:description]}\n" if output_spec[:description]
+          end
+          output += "\n"
+        end
+
+        unless capability.dependencies.empty?
+          output += "Dependencies:\n"
+          capability.dependencies.each do |dep|
+            output += "  - #{UI.colorize(dep[:name], :magenta)} (#{dep[:version] || "any version"})\n"
+          end
+        end
+
+        puts UI.box(
+          "Capability Details",
+          output,
+          padding: [1, 2, 1, 2],
+          style: {border: {fg: :blue}}
+        )
+      end
+
+      desc "search QUERY", "Search for capabilities"
+      def search(query)
+        # Initialize agent assembly system
+        Agentic.initialize_agent_assembly
+        registry = Agentic.agent_capability_registry
+
+        # Search by name and description
+        capabilities = registry.list
+        results = {}
+
+        capabilities.each do |name, info|
+          # Check if query matches capability name
+          if name.downcase.include?(query.downcase)
+            results[name] = info
+            next
+          end
+
+          # Check if query matches capability description
+          capability = registry.get(name, info[:latest])
+          if capability && capability.description.downcase.include?(query.downcase)
+            results[name] = info
+          end
+        end
+
+        if results.empty?
+          puts UI.box(
+            "Search Results",
+            "No capabilities found matching '#{UI.colorize(query, :yellow)}'.",
+            padding: [1, 2, 1, 2],
+            style: {border: {fg: :blue}}
+          )
+          return
+        end
+
+        output = ""
+        results.each do |name, info|
+          capability = registry.get(name, info[:latest])
+
+          output += "#{UI.colorize(name, :blue)}:\n"
+          output += "  Latest version: #{UI.colorize(info[:latest], :green)}\n"
+          output += "  Description: #{capability.description}\n\n"
+        end
+
+        puts UI.box(
+          "Search Results",
+          output,
+          padding: [1, 2, 1, 2],
+          style: {border: {fg: :blue}}
+        )
+      end
+    end
+  end
+end

data/lib/agentic/cli/config.rb

@@ -0,0 +1,134 @@
+# frozen_string_literal: true
+
+require "yaml"
+require "fileutils"
+
+module Agentic
+  class CLI < Thor
+    # CLI commands for managing configuration
+    class Config < Thor
+      CONFIG_FILE_NAME = ".agentic.yml"
+      USER_CONFIG_PATH = File.join(Dir.home, CONFIG_FILE_NAME)
+      PROJECT_CONFIG_PATH = File.join(Dir.pwd, CONFIG_FILE_NAME)
+
+      desc "list", "List configuration settings"
+      def list
+        user_config = load_config(USER_CONFIG_PATH)
+        project_config = load_config(PROJECT_CONFIG_PATH)
+
+        puts "User configuration (#{USER_CONFIG_PATH}):"
+        print_config(user_config)
+
+        puts "\nProject configuration (#{PROJECT_CONFIG_PATH}):"
+        print_config(project_config)
+
+        puts "\nActive configuration:"
+        print_config(active_config)
+
+        puts "\nEnvironment variables:"
+        puts "  OPENAI_ACCESS_TOKEN: #{ENV["OPENAI_ACCESS_TOKEN"] ? "[SET]" : "[NOT SET]"}"
+      end
+
+      desc "get KEY", "Get a configuration setting"
+      def get(key)
+        config = active_config
+        value = config[key]
+
+        if value
+          puts value
+        else
+          puts "Key '#{key}' not found in configuration"
+          exit 1
+        end
+      end
+
+      desc "set KEY=VALUE", "Set a configuration setting"
+      option :global, type: :boolean, aliases: "-g",
+        desc: "Set in global user config instead of project config"
+      def set(key_value)
+        key, value = key_value.split("=", 2)
+
+        unless value
+          puts "Error: Invalid format. Use KEY=VALUE"
+          exit 1
+        end
+
+        path = options[:global] ? USER_CONFIG_PATH : PROJECT_CONFIG_PATH
+        config = load_config(path) || {}
+
+        # Convert string values to appropriate types
+        value = case value.downcase
+        when "true" then true
+        when "false" then false
+        when /^\d+$/ then value.to_i
+        when /^\d+\.\d+$/ then value.to_f
+        else value
+        end
+
+        config[key] = value
+        save_config(path, config)
+
+        puts "Configuration updated successfully."
+      end
+
+      desc "init", "Initialize configuration"
+      option :global, type: :boolean, aliases: "-g",
+        desc: "Initialize global user config instead of project config"
+      def init
+        path = options[:global] ? USER_CONFIG_PATH : PROJECT_CONFIG_PATH
+
+        if File.exist?(path)
+          puts "Configuration already exists at #{path}"
+          return
+        end
+
+        config = {
+          "model" => "gpt-4o-mini"
+          # Add other default configuration options here
+        }
+
+        save_config(path, config)
+        puts "Configuration initialized at #{path}"
+      end
+
+      private
+
+      def load_config(path)
+        return unless File.exist?(path)
+
+        begin
+          YAML.load_file(path)
+        rescue => e
+          puts "Error loading configuration from #{path}: #{e.message}"
+          nil
+        end
+      end
+
+      def save_config(path, config)
+        # Create directory if it doesn't exist
+        dir = File.dirname(path)
+        FileUtils.mkdir_p(dir) unless File.directory?(dir)
+
+        File.write(path, YAML.dump(config))
+      end
+
+      def active_config
+        # Combine user and project configs, with project taking precedence
+        user_config = load_config(USER_CONFIG_PATH) || {}
+        project_config = load_config(PROJECT_CONFIG_PATH) || {}
+
+        user_config.merge(project_config)
+      end
+
+      def print_config(config)
+        if config.nil? || config.empty?
+          puts "  [empty]"
+        else
+          config.each do |key, value|
+            puts "  #{key}: #{value}"
+          end
+        end
+      end
+    end
+  end
+end