igniter 0.5.0 → 0.5.1

data/lib/igniter/server/router.rb

@@ -1,108 +0,0 @@
-# frozen_string_literal: true
-
-require "json"
-
-module Igniter
-  module Server
-    # Transport-agnostic HTTP router.
-    # Receives (method, path, body_string) and returns { status:, body:, headers: }.
-    # Used by both HttpServer (TCPServer) and RackApp.
-    class Router
-      ROUTES = [
-        { method: "GET",    pattern: %r{\A/v1/live\z},                             handler: :liveness },
-        { method: "GET",    pattern: %r{\A/v1/ready\z},                            handler: :readiness },
-        { method: "GET",    pattern: %r{\A/v1/metrics\z},                          handler: :metrics },
-        { method: "GET",    pattern: %r{\A/v1/health\z},                           handler: :health },
-        { method: "GET",    pattern: %r{\A/v1/manifest\z},                         handler: :manifest },
-        { method: "GET",    pattern: %r{\A/v1/mesh/peers\z},                       handler: :mesh_peers_list },
-        { method: "GET",    pattern: %r{\A/v1/mesh/sd\z}, handler: :mesh_sd },
-        { method: "POST",   pattern: %r{\A/v1/mesh/peers\z},                       handler: :mesh_peers_register },
-        { method: "DELETE", pattern: %r{\A/v1/mesh/peers/(?<name>.+)\z},           handler: :mesh_peers_delete },
-        { method: "GET",    pattern: %r{\A/v1/contracts\z},                        handler: :contracts },
-        { method: "POST",   pattern: %r{\A/v1/contracts/(?<name>[^/]+)/execute\z}, handler: :execute },
-        { method: "POST",   pattern: %r{\A/v1/contracts/(?<name>[^/]+)/events\z},  handler: :event },
-        { method: "GET",    pattern: %r{\A/v1/executions/(?<id>[^/]+)\z},          handler: :status }
-      ].freeze
-
-      def initialize(config)
-        @config = config
-      end
-
-      # Main dispatch entry point — called by both HttpServer and RackApp.
-      # Records HTTP metrics when a collector is configured.
-      def call(http_method, path, body_str) # rubocop:disable Metrics/MethodLength,Metrics/AbcSize
-        started_at = Time.now.utc
-        method_uc  = http_method.to_s.upcase
-
-        ROUTES.each do |route|
-          next unless route[:method] == method_uc
-
-          match = route[:pattern].match(path)
-          next unless match
-
-          params  = match.named_captures.transform_keys(&:to_sym)
-          body    = parse_body(body_str)
-          handler = build_handler(route[:handler])
-          result  = handler.call(params: params, body: body)
-
-          record_http_metric(method_uc, path, result[:status], started_at)
-          return result
-        end
-
-        result = not_found_response(path)
-        record_http_metric(method_uc, path, 404, started_at)
-        result
-      rescue JSON::ParserError => e
-        { status: 400, body: JSON.generate({ error: "Invalid JSON: #{e.message}" }), headers: json_ct }
-      end
-
-      private
-
-      def build_handler(key) # rubocop:disable Metrics/MethodLength, Metrics/AbcSize, Metrics/CyclomaticComplexity
-        registry  = @config.registry
-        store     = @config.store
-        node_url  = "http://#{@config.host}:#{@config.port}"
-        collector = @config.metrics_collector
-
-        case key
-        when :liveness           then Handlers::LivenessHandler.new(registry, store)
-        when :readiness          then Handlers::ReadinessHandler.new(registry, store)
-        when :metrics            then Handlers::MetricsHandler.new(registry, store, collector: collector)
-        when :health             then Handlers::HealthHandler.new(registry, store, node_url: node_url)
-        when :manifest           then Handlers::ManifestHandler.new(registry, store, config: @config)
-        when :mesh_peers_list    then Handlers::MeshPeersListHandler.new(registry, store)
-        when :mesh_sd            then Handlers::MeshSdHandler.new(registry, store)
-        when :mesh_peers_register then Handlers::MeshPeersRegisterHandler.new(registry, store)
-        when :mesh_peers_delete  then Handlers::MeshPeersDeleteHandler.new(registry, store)
-        when :contracts          then Handlers::ContractsHandler.new(registry, store)
-        when :execute            then Handlers::ExecuteHandler.new(registry, store, collector: collector)
-        when :event              then Handlers::EventHandler.new(registry, store, collector: collector)
-        when :status             then Handlers::StatusHandler.new(registry, store)
-        end
-      end
-
-      def record_http_metric(method, path, status, started_at)
-        return unless @config.metrics_collector
-
-        duration = Time.now.utc - started_at
-        @config.metrics_collector.record_http(
-          method: method, path: path, status: status, duration: duration
-        )
-      end
-
-      def parse_body(str)
-        return {} if str.nil? || str.strip.empty?
-
-        JSON.parse(str)
-      end
-
-      def not_found_response(path)
-        { status: 404, body: JSON.generate({ error: "Not found: #{path}" }), headers: json_ct }
-      end
-
-      def json_ct
-        { "Content-Type" => "application/json" }
-      end
-    end
-  end
-end

data/lib/igniter/skill.rb

@@ -1,218 +0,0 @@
-# frozen_string_literal: true
-
-require_relative "tool"
-require_relative "integrations/llm/executor"
-
-module Igniter
-  # Base class for AI-callable skills — composable units of agent capability.
-  #
-  # A +Skill+ is both discoverable (LLM can call it like a Tool) and agentic
-  # (it runs its own LLM reasoning loop with its own set of tools).
-  # Use Skills when a single tool call is not enough: the task requires planning,
-  # multi-step tool use, or internal LLM reasoning.
-  #
-  # == Tool vs Skill
-  #
-  # +Tool+  — atomic operation, single call, stateless, fast.
-  # +Skill+ — multi-step process, own LLM loop, own tools, may take seconds.
-  #
-  # From the parent agent's perspective both look identical: they share the same
-  # discovery interface (+description+, +param+, +to_schema+, +requires_capability+)
-  # and are registered in +ToolRegistry+ the same way.
-  #
-  # == Defining a skill
-  #
-  #   class ResearchSkill < Igniter::Skill
-  #     description "Research a topic by searching and synthesizing multiple sources"
-  #
-  #     param :topic, type: :string, required: true,
-  #                   desc: "Subject to research"
-  #
-  #     requires_capability :network
-  #
-  #     provider :anthropic
-  #     model "claude-sonnet-4-6"
-  #     tools SearchWebTool, ReadUrlTool   # skill's own sub-tools
-  #     max_tool_iterations 8
-  #
-  #     def call(topic:)
-  #       complete("Research this thoroughly: #{topic}")
-  #       # ↑ runs sub-tool loop internally; returns plain-text summary
-  #     end
-  #   end
-  #
-  # == Structured output
-  #
-  #   class AnalysisSkill < Igniter::Skill
-  #     output_schema do
-  #       field :summary,    String
-  #       field :confidence, Float
-  #     end
-  #
-  #     def call(document:)
-  #       complete("Analyse: #{document}")
-  #       # Returns StructuredResult, not a plain String
-  #     end
-  #   end
-  #
-  # == Feedback loop
-  #
-  #   class MySkill < Igniter::Skill
-  #     feedback_enabled true
-  #     feedback_store   :memory
-  #
-  #     def call(prompt:) = complete(prompt)
-  #   end
-  #
-  #   result = MySkill.call(prompt: "...")
-  #   MySkill.new.feedback(result, rating: :good, notes: "Very helpful")
-  #   improved = MySkill.new.refine_system_prompt
-  #
-  # == Hierarchical agents
-  #
-  #   class ChatExecutor < Igniter::LLM::Executor
-  #     tools TimeTool, WeatherTool,
-  #           ResearchSkill,   # ← parent sees this as a Tool
-  #           WriteCodeSkill   # ← parent sees this as a Tool
-  #   end
-  #
-  # == Schema + registry
-  #
-  #   ResearchSkill.tool_name          # => "research_skill"
-  #   ResearchSkill.to_schema          # => { name:, description:, parameters: { ... } }
-  #   Igniter::ToolRegistry.register(ResearchSkill)
-  class Skill < LLM::Executor
-    # CapabilityError is the same class as Tool::CapabilityError.
-    # Defined here as an alias for convenience and symmetry.
-    CapabilityError = Tool::CapabilityError
-
-    include Tool::Discoverable
-
-    class << self
-      # Propagate BOTH the LLM executor config (via super → LLM::Executor.inherited)
-      # AND the Discoverable metadata to every subclass.
-      # Note: @feedback_store is intentionally NOT copied — each class owns its store.
-      def inherited(subclass)
-        super
-        subclass.instance_variable_set(:@output_schema, @output_schema)
-        subclass.instance_variable_set(:@feedback_enabled, @feedback_enabled)
-        copy_discoverable_state_to(subclass)
-      end
-
-      # Declare a typed JSON output schema for this skill.
-      #
-      # When a block is given, creates an +OutputSchema+ and stores it.
-      # Calling +complete+ inside +call+ will then inject a JSON instruction
-      # into the prompt and return a +StructuredResult+ instead of a String.
-      #
-      # Without a block, falls back to the inherited +Executor#output_schema+
-      # metadata getter/setter for backward compatibility.
-      #
-      # @example
-      #   output_schema do
-      #     field :summary,    String
-      #     field :confidence, Float
-      #     field :sources,    Array
-      #   end
-      def output_schema(value = nil, &block)
-        if block
-          @output_schema = Skill::OutputSchema.new(&block)
-        elsif value
-          super(value)             # Executor metadata setter (backward compat)
-        else
-          @output_schema || super  # new DSL ivar or executor_metadata fallback
-        end
-      end
-
-      # Enable or query feedback collection for this skill.
-      # When enabled, +#feedback+ stores entries in the configured store.
-      #
-      # @param val [Boolean, nil] pass true/false to set; nil to get
-      def feedback_enabled(val = nil)
-        val.nil? ? (@feedback_enabled || false) : (@feedback_enabled = val)
-      end
-
-      # Set or get the feedback store for this skill.
-      #
-      # Pass +:memory+ to create a new in-memory store (one per class).
-      # Pass any object responding to +#store+, +#all+, and +#clear+ to use a custom store.
-      #
-      # Note: the store is NOT inherited by subclasses — each class has its own.
-      #
-      # @param val [:memory, #store, nil]
-      def feedback_store(val = nil)
-        return @feedback_store if val.nil?
-
-        @feedback_store = val == :memory ? Skill::FeedbackStore::Memory.new : val
-      end
-    end
-
-    protected
-
-    # Override LLM::Executor#complete to inject a JSON instruction when an
-    # +OutputSchema+ is declared, and parse the response into a +StructuredResult+.
-    def complete(prompt, context: nil)
-      schema = self.class.output_schema
-
-      adjusted = if schema.is_a?(Skill::OutputSchema)
-                   "#{prompt}\n\nRespond ONLY with valid JSON matching this schema: #{schema.to_json_description}"
-                 else
-                   prompt
-                 end
-
-      result = super(adjusted, context: context)
-      schema.is_a?(Skill::OutputSchema) ? schema.parse(result) : result
-    end
-
-    public
-
-    # Record feedback for a previous output.
-    #
-    # Matches +output+ against +call_history+ to capture the input context.
-    # No-op when +feedback_enabled+ is false or no store is configured.
-    #
-    # @param output [String, StructuredResult] the response to rate
-    # @param rating [:good, :bad, :neutral]
-    # @param notes  [String, nil]
-    # @return [self]
-    def feedback(output, rating:, notes: nil) # rubocop:disable Metrics/MethodLength
-      return self unless self.class.feedback_enabled
-
-      store = self.class.feedback_store
-      return self unless store
-
-      output_str = output.to_s
-      matched    = (call_history || []).reverse.find { |h| h[:output] == output_str }
-
-      store.store(FeedbackEntry.new(
-                    input: matched&.dig(:input),
-                    output: output_str,
-                    rating: rating.to_sym,
-                    notes: notes,
-                    timestamp: Time.now
-                  ))
-      self
-    end
-
-    # Generate an improved system prompt based on accumulated feedback.
-    #
-    # Uses the skill's own LLM provider + model. Returns a new String — does NOT
-    # mutate class-level state. The caller decides whether to adopt the result.
-    #
-    # @return [String] the refined system prompt
-    # @raise [Igniter::Error] if no feedback_store is configured
-    def refine_system_prompt
-      store = self.class.feedback_store
-      raise Igniter::Error, "No feedback_store configured on #{self.class.name}" unless store
-
-      FeedbackRefiner.new(provider_instance, current_model).refine(
-        self.class.system_prompt.to_s,
-        store.all
-      )
-    end
-  end
-end
-
-# Load sub-files that reopen Skill after it is fully defined above.
-require_relative "skill/output_schema"
-require_relative "skill/feedback"

data/lib/igniter/tool_registry.rb

@@ -1,144 +0,0 @@
-# frozen_string_literal: true
-
-require_relative "tool"
-require_relative "skill"
-
-module Igniter
-  # Global registry for Igniter::Tool and Igniter::Skill classes.
-  #
-  # Both Tools (atomic operations) and Skills (agentic sub-processes) share the
-  # same discovery interface and are registered the same way. The registry does
-  # not distinguish between them — from a caller's perspective both are callable
-  # units described by name, description, and a parameter schema.
-  #
-  # == Scopes
-  #
-  # Every entry belongs to one of three scopes:
-  #   :bundled   — shipped with the core library
-  #   :managed   — installed from an external registry or package manager
-  #   :workspace — local, app-specific (default)
-  #
-  # Scope does not affect capability filtering or schema generation unless you
-  # pass +scope:+ explicitly. All existing calls without +scope:+ continue to
-  # work exactly as before.
-  #
-  # == Registration
-  #
-  #   Igniter::ToolRegistry.register(SearchWeb, WriteFile, ResearchSkill)
-  #   Igniter::ToolRegistry.register(WeatherTool, scope: :bundled)
-  #
-  # == Discovery
-  #
-  #   Igniter::ToolRegistry.all
-  #   # => [SearchWeb, WriteFile, ResearchSkill, WeatherTool]
-  #
-  #   Igniter::ToolRegistry.all(scope: :bundled)
-  #   # => [WeatherTool]
-  #
-  #   Igniter::ToolRegistry.tools_for(capabilities: [:web_access])
-  #   Igniter::ToolRegistry.tools_for(capabilities: [:web_access], scope: :workspace)
-  #
-  # == Schema generation
-  #
-  #   Igniter::ToolRegistry.schemas(:anthropic)
-  #   Igniter::ToolRegistry.schemas(:openai, capabilities: [:web_access], scope: :managed)
-  module ToolRegistry
-    # Valid scope identifiers, ordered from least to most specific.
-    SCOPES = %i[bundled managed workspace].freeze
-
-    # Internal store: { tool_name_string => { klass: Class, scope: Symbol } }
-    @tools = {}
-
-    class << self
-      # Register one or more Tool or Skill subclasses.
-      #
-      # @param tool_classes [Array<Class>] Tool or Skill subclasses
-      # @param scope        [Symbol]       :bundled, :managed, or :workspace (default)
-      # @raise [ArgumentError] if a class is not discoverable or scope is invalid
-      def register(*tool_classes, scope: :workspace) # rubocop:disable Metrics/MethodLength
-        unless SCOPES.include?(scope)
-          raise ArgumentError, "Invalid scope #{scope.inspect}. Must be one of #{SCOPES.inspect}"
-        end
-
-        tool_classes.flatten.each do |klass|
-          unless discoverable?(klass)
-            raise ArgumentError,
-                  "#{klass.inspect} must be an Igniter::Tool or Igniter::Skill subclass"
-          end
-
-          @tools[klass.tool_name] = { klass: klass, scope: scope }
-        end
-        self
-      end
-
-      # Look up a tool or skill by its snake_case name.
-      # @param name [String, Symbol]
-      # @return [Class, nil]
-      def find(name)
-        @tools[name.to_s]&.fetch(:klass)
-      end
-
-      # All registered classes, optionally filtered by scope.
-      #
-      # @param scope [Symbol, nil] :bundled, :managed, :workspace, or nil for all
-      # @return [Array<Class>]
-      def all(scope: nil)
-        entries_for(scope).map { |e| e[:klass] }
-      end
-
-      # Classes whose required capabilities are fully covered by +capabilities+.
-      # Tools/skills with no required capabilities are always included.
-      #
-      # @param capabilities [Array<Symbol>]
-      # @param scope        [Symbol, nil]
-      # @return [Array<Class>]
-      def tools_for(capabilities: [], scope: nil)
-        allowed  = capabilities.map(&:to_sym).to_set
-        matching = entries_for(scope).select do |e|
-          e[:klass].required_capabilities.all? { |c| allowed.include?(c) }
-        end
-        matching.map { |e| e[:klass] }
-      end
-
-      # Generate schemas for the given provider.
-      # Optionally filter by capabilities and/or scope.
-      #
-      # @param provider      [Symbol]        :anthropic, :openai, or nil for intermediate
-      # @param capabilities  [Array<Symbol>] optional capability filter
-      # @param scope         [Symbol, nil]   optional scope filter
-      # @return [Array<Hash>]
-      def schemas(provider = nil, capabilities: nil, scope: nil)
-        list = if capabilities
-                 tools_for(capabilities: capabilities, scope: scope)
-               else
-                 all(scope: scope)
-               end
-        list.map { |klass| klass.to_schema(provider) }
-      end
-
-      # Number of registered classes (across all scopes).
-      def size = @tools.size
-
-      # True if nothing is registered.
-      def empty? = @tools.empty?
-
-      # Remove all registrations (primarily for tests).
-      def clear!
-        @tools = {}
-        self
-      end
-
-      private
-
-      def entries_for(scope)
-        scope ? @tools.values.select { |e| e[:scope] == scope } : @tools.values
-      end
-
-      # A class is discoverable if it is a Tool or Skill (includes Tool::Discoverable).
-      def discoverable?(klass)
-        klass.is_a?(Class) &&
-          (klass < Igniter::Tool || klass < Igniter::Skill)
-      end
-    end
-  end
-end