@dewtech/dare-cli 3.2.0 → 3.4.0

package/templates/stacks/ruby-rails-8/app/llm/providers/dummy_provider.rb

@@ -1,35 +1,35 @@
-# frozen_string_literal: true
-
-# DARE v3.0 — DummyProvider for testing and development
-# Returns deterministic canned responses — no network calls
-
-module LLM
-  module Providers
-    class DummyProvider < LLMProvider
-      DEFAULT_RESPONSE = "This is a dummy LLM response. Configure a real provider in config/dare.yml."
-
-      def initialize(responses: {})
-        # Allow injecting specific responses by prompt keyword for tests:
-        # DummyProvider.new(responses: { "summarize" => "Summary here" })
-        @responses = responses
-      end
-
-      def complete(model:, prompt:, max_tokens: 1024, temperature: 0.7, **_opts)
-        matched_key = @responses.keys.find { |k| prompt.to_s.downcase.include?(k.to_s.downcase) }
-        @responses.fetch(matched_key, DEFAULT_RESPONSE)
-      end
-
-      def chat(model:, messages:, max_tokens: 1024, temperature: 0.7, **_opts)
-        last_content = messages.last&.dig(:content) || messages.last&.dig("content") || ""
-        complete(model: model, prompt: last_content, max_tokens: max_tokens)
-      end
-
-      def stream(model:, prompt:, max_tokens: 1024, &block)
-        response = complete(model: model, prompt: prompt, max_tokens: max_tokens)
-        response.chars.each_slice(10).map(&:join).each do |chunk|
-          block.call(chunk)
-        end
-      end
-    end
-  end
-end
+# frozen_string_literal: true
+
+# DARE v3.0 — DummyProvider for testing and development
+# Returns deterministic canned responses — no network calls
+
+module LLM
+  module Providers
+    class DummyProvider < LLMProvider
+      DEFAULT_RESPONSE = "This is a dummy LLM response. Configure a real provider in config/dare.yml."
+
+      def initialize(responses: {})
+        # Allow injecting specific responses by prompt keyword for tests:
+        # DummyProvider.new(responses: { "summarize" => "Summary here" })
+        @responses = responses
+      end
+
+      def complete(model:, prompt:, max_tokens: 1024, temperature: 0.7, **_opts)
+        matched_key = @responses.keys.find { |k| prompt.to_s.downcase.include?(k.to_s.downcase) }
+        @responses.fetch(matched_key, DEFAULT_RESPONSE)
+      end
+
+      def chat(model:, messages:, max_tokens: 1024, temperature: 0.7, **_opts)
+        last_content = messages.last&.dig(:content) || messages.last&.dig("content") || ""
+        complete(model: model, prompt: last_content, max_tokens: max_tokens)
+      end
+
+      def stream(model:, prompt:, max_tokens: 1024, &block)
+        response = complete(model: model, prompt: prompt, max_tokens: max_tokens)
+        response.chars.each_slice(10).map(&:join).each do |chunk|
+          block.call(chunk)
+        end
+      end
+    end
+  end
+end

package/templates/stacks/ruby-rails-8/app/llm/providers/llm_provider.rb

@@ -1,67 +1,67 @@
-# frozen_string_literal: true
-
-# DARE v3.0 — LLMProvider interface
-# Convention (ADR-04): all LLM calls go through this interface
-# Implementations: OpenaiProvider, DummyProvider, LocalLlamaProvider
-#
-# Usage:
-#   LLMProvider.instance.complete(model: "gpt-4o", prompt: "Summarize...", max_tokens: 150)
-
-module LLM
-  module Providers
-    class LLMProvider
-      include Singleton
-
-      # ── Factory: configure at boot from dare.yml ─────────────────────────
-
-      # Override the singleton instance (useful in tests to inject DummyProvider)
-      def self.configure(provider_instance)
-        @configured_instance = provider_instance
-      end
-
-      def self.instance
-        @configured_instance ||= build_from_config
-      end
-
-      def self.build_from_config
-        provider_name = Rails.configuration.dare.llm_provider
-
-        case provider_name
-        when "openai"
-          LLM::Providers::OpenaiProvider.new
-        when "dummy"
-          LLM::Providers::DummyProvider.new
-        else
-          raise ArgumentError, "Unknown LLM provider: #{provider_name}. Valid: openai, dummy"
-        end
-      end
-
-      # ── Interface — subclasses must implement ─────────────────────────────
-
-      # Complete a prompt and return the response text.
-      #
-      # @param model      [String]  e.g. "gpt-4o"
-      # @param prompt     [String]  the full prompt text
-      # @param max_tokens [Integer] maximum tokens in response
-      # @param temperature [Float]  0.0 to 1.0
-      # @return [String] the completion text
-      def complete(model:, prompt:, max_tokens: 1024, temperature: 0.7, **_opts)
-        raise NotImplementedError, "#{self.class} must implement #complete"
-      end
-
-      # Chat-style completion with messages array
-      #
-      # @param model    [String]
-      # @param messages [Array<Hash>] [{role: "user", content: "..."}]
-      # @return [String] assistant message content
-      def chat(model:, messages:, max_tokens: 1024, temperature: 0.7, **_opts)
-        raise NotImplementedError, "#{self.class} must implement #chat"
-      end
-
-      # Stream a completion — yields chunks as they arrive.
-      def stream(model:, prompt:, max_tokens: 1024, &block)
-        raise NotImplementedError, "#{self.class} must implement #stream"
-      end
-    end
-  end
-end
+# frozen_string_literal: true
+
+# DARE v3.0 — LLMProvider interface
+# Convention (ADR-04): all LLM calls go through this interface
+# Implementations: OpenaiProvider, DummyProvider, LocalLlamaProvider
+#
+# Usage:
+#   LLMProvider.instance.complete(model: "gpt-4o", prompt: "Summarize...", max_tokens: 150)
+
+module LLM
+  module Providers
+    class LLMProvider
+      include Singleton
+
+      # ── Factory: configure at boot from dare.yml ─────────────────────────
+
+      # Override the singleton instance (useful in tests to inject DummyProvider)
+      def self.configure(provider_instance)
+        @configured_instance = provider_instance
+      end
+
+      def self.instance
+        @configured_instance ||= build_from_config
+      end
+
+      def self.build_from_config
+        provider_name = Rails.configuration.dare.llm_provider
+
+        case provider_name
+        when "openai"
+          LLM::Providers::OpenaiProvider.new
+        when "dummy"
+          LLM::Providers::DummyProvider.new
+        else
+          raise ArgumentError, "Unknown LLM provider: #{provider_name}. Valid: openai, dummy"
+        end
+      end
+
+      # ── Interface — subclasses must implement ─────────────────────────────
+
+      # Complete a prompt and return the response text.
+      #
+      # @param model      [String]  e.g. "gpt-4o"
+      # @param prompt     [String]  the full prompt text
+      # @param max_tokens [Integer] maximum tokens in response
+      # @param temperature [Float]  0.0 to 1.0
+      # @return [String] the completion text
+      def complete(model:, prompt:, max_tokens: 1024, temperature: 0.7, **_opts)
+        raise NotImplementedError, "#{self.class} must implement #complete"
+      end
+
+      # Chat-style completion with messages array
+      #
+      # @param model    [String]
+      # @param messages [Array<Hash>] [{role: "user", content: "..."}]
+      # @return [String] assistant message content
+      def chat(model:, messages:, max_tokens: 1024, temperature: 0.7, **_opts)
+        raise NotImplementedError, "#{self.class} must implement #chat"
+      end
+
+      # Stream a completion — yields chunks as they arrive.
+      def stream(model:, prompt:, max_tokens: 1024, &block)
+        raise NotImplementedError, "#{self.class} must implement #stream"
+      end
+    end
+  end
+end

package/templates/stacks/ruby-rails-8/app/llm/providers/openai_provider.rb

@@ -1,62 +1,62 @@
-# frozen_string_literal: true
-
-# DARE v3.0 — OpenAI LLM provider
-# Uses Faraday for HTTP — no heavy SDK dependency
-
-module LLM
-  module Providers
-    class OpenaiProvider < LLMProvider
-      BASE_URL = "https://api.openai.com/v1"
-
-      def initialize(api_key: nil)
-        @api_key = api_key || Rails.configuration.dare.llm_api_key
-        raise ArgumentError, "OpenAI API key not configured. Set OPENAI_API_KEY." if @api_key.blank?
-      end
-
-      def complete(model:, prompt:, max_tokens: 1024, temperature: 0.7, **_opts)
-        messages = [{ role: "user", content: prompt }]
-        chat(model: model, messages: messages, max_tokens: max_tokens, temperature: temperature)
-      end
-
-      def chat(model:, messages:, max_tokens: 1024, temperature: 0.7, **_opts)
-        response = connection.post("/v1/chat/completions") do |req|
-          req.headers["Authorization"] = "Bearer #{@api_key}"
-          req.headers["Content-Type"]  = "application/json"
-          req.body = {
-            model:       model,
-            messages:    messages,
-            max_tokens:  max_tokens,
-            temperature: temperature
-          }.to_json
-        end
-
-        handle_response(response)
-          .dig("choices", 0, "message", "content")
-          .to_s
-          .strip
-      end
-
-      def stream(model:, prompt:, max_tokens: 1024, &block)
-        # Streaming via SSE — basic implementation
-        # For production use consider openai-ruby gem with native streaming
-        raise NotImplementedError, "Streaming not yet implemented in OpenaiProvider. Use chat() instead."
-      end
-
-      private
-
-      def connection
-        @connection ||= Faraday.new(url: BASE_URL) do |f|
-          f.request  :retry, max: 2, interval: 0.5, retry_statuses: [429, 503]
-          f.response :raise_error
-          f.adapter  Faraday.default_adapter
-        end
-      end
-
-      def handle_response(response)
-        JSON.parse(response.body)
-      rescue JSON::ParserError => e
-        raise "OpenAI returned non-JSON response: #{response.body.truncate(200)}"
-      end
-    end
-  end
-end
+# frozen_string_literal: true
+
+# DARE v3.0 — OpenAI LLM provider
+# Uses Faraday for HTTP — no heavy SDK dependency
+
+module LLM
+  module Providers
+    class OpenaiProvider < LLMProvider
+      BASE_URL = "https://api.openai.com/v1"
+
+      def initialize(api_key: nil)
+        @api_key = api_key || Rails.configuration.dare.llm_api_key
+        raise ArgumentError, "OpenAI API key not configured. Set OPENAI_API_KEY." if @api_key.blank?
+      end
+
+      def complete(model:, prompt:, max_tokens: 1024, temperature: 0.7, **_opts)
+        messages = [{ role: "user", content: prompt }]
+        chat(model: model, messages: messages, max_tokens: max_tokens, temperature: temperature)
+      end
+
+      def chat(model:, messages:, max_tokens: 1024, temperature: 0.7, **_opts)
+        response = connection.post("/v1/chat/completions") do |req|
+          req.headers["Authorization"] = "Bearer #{@api_key}"
+          req.headers["Content-Type"]  = "application/json"
+          req.body = {
+            model:       model,
+            messages:    messages,
+            max_tokens:  max_tokens,
+            temperature: temperature
+          }.to_json
+        end
+
+        handle_response(response)
+          .dig("choices", 0, "message", "content")
+          .to_s
+          .strip
+      end
+
+      def stream(model:, prompt:, max_tokens: 1024, &block)
+        # Streaming via SSE — basic implementation
+        # For production use consider openai-ruby gem with native streaming
+        raise NotImplementedError, "Streaming not yet implemented in OpenaiProvider. Use chat() instead."
+      end
+
+      private
+
+      def connection
+        @connection ||= Faraday.new(url: BASE_URL) do |f|
+          f.request  :retry, max: 2, interval: 0.5, retry_statuses: [429, 503]
+          f.response :raise_error
+          f.adapter  Faraday.default_adapter
+        end
+      end
+
+      def handle_response(response)
+        JSON.parse(response.body)
+      rescue JSON::ParserError => e
+        raise "OpenAI returned non-JSON response: #{response.body.truncate(200)}"
+      end
+    end
+  end
+end

package/templates/stacks/ruby-rails-8/app/llm/rate_limit/token_bucket.rb

@@ -1,82 +1,82 @@
-# frozen_string_literal: true
-
-# DARE v3.0 — Token Bucket rate limiter for LLM API calls
-# Prevents exceeding OpenAI/provider rate limits (tokens per minute)
-# Uses Redis for distributed state across multiple app instances
-#
-# Usage:
-#   bucket = LLM::RateLimit::TokenBucket.new(user_id: current_user.id)
-#   unless bucket.consume!(tokens: estimated_tokens)
-#     raise RateLimitExceeded, "LLM token limit reached. Retry after #{bucket.retry_after}s"
-#   end
-
-module LLM
-  module RateLimit
-    class TokenBucket
-      class RateLimitExceeded < StandardError
-        attr_reader :retry_after
-
-        def initialize(retry_after: 60)
-          @retry_after = retry_after
-          super("LLM token rate limit exceeded. Retry after #{retry_after} seconds.")
-        end
-      end
-
-      # Default: 100K tokens per minute per user (well below OpenAI limits)
-      DEFAULT_CAPACITY   = 100_000
-      DEFAULT_REFILL_RPM = 100_000  # tokens refilled per minute
-      WINDOW_SECONDS     = 60
-
-      def initialize(user_id:, capacity: DEFAULT_CAPACITY)
-        @user_id  = user_id
-        @capacity = capacity
-        @redis    = Redis.new(url: Rails.configuration.dare.redis_url)
-      end
-
-      # Attempt to consume tokens. Returns true if allowed, false if rate-limited.
-      def consume!(tokens: 1)
-        key       = redis_key
-        now       = Time.now.to_f
-        window_start = now - WINDOW_SECONDS
-
-        # Redis pipeline: count tokens used in current window + add new entry
-        used = @redis.multi do |pipeline|
-          pipeline.zremrangebyscore(key, "-inf", window_start)
-          pipeline.zadd(key, now, "#{now}:#{tokens}")
-          pipeline.zrange(key, 0, -1)
-          pipeline.expire(key, WINDOW_SECONDS * 2)
-        end
-
-        # Tally tokens from sorted set entries
-        entries = used[2] || []
-        total_used = entries.sum do |entry|
-          entry.split(":").last.to_i
-        end
-
-        if total_used > @capacity
-          # Roll back the zadd we just did
-          @redis.zrem(key, "#{now}:#{tokens}")
-          return false
-        end
-
-        true
-      end
-
-      def retry_after
-        # Time until oldest entry expires
-        oldest = @redis.zrange(redis_key, 0, 0, with_scores: true).first
-        return 0 unless oldest
-
-        oldest_time = oldest[1]
-        remaining = (oldest_time + WINDOW_SECONDS) - Time.now.to_f
-        [remaining.ceil, 0].max
-      end
-
-      private
-
-      def redis_key
-        "llm_token_bucket:#{@user_id}"
-      end
-    end
-  end
-end
+# frozen_string_literal: true
+
+# DARE v3.0 — Token Bucket rate limiter for LLM API calls
+# Prevents exceeding OpenAI/provider rate limits (tokens per minute)
+# Uses Redis for distributed state across multiple app instances
+#
+# Usage:
+#   bucket = LLM::RateLimit::TokenBucket.new(user_id: current_user.id)
+#   unless bucket.consume!(tokens: estimated_tokens)
+#     raise RateLimitExceeded, "LLM token limit reached. Retry after #{bucket.retry_after}s"
+#   end
+
+module LLM
+  module RateLimit
+    class TokenBucket
+      class RateLimitExceeded < StandardError
+        attr_reader :retry_after
+
+        def initialize(retry_after: 60)
+          @retry_after = retry_after
+          super("LLM token rate limit exceeded. Retry after #{retry_after} seconds.")
+        end
+      end
+
+      # Default: 100K tokens per minute per user (well below OpenAI limits)
+      DEFAULT_CAPACITY   = 100_000
+      DEFAULT_REFILL_RPM = 100_000  # tokens refilled per minute
+      WINDOW_SECONDS     = 60
+
+      def initialize(user_id:, capacity: DEFAULT_CAPACITY)
+        @user_id  = user_id
+        @capacity = capacity
+        @redis    = Redis.new(url: Rails.configuration.dare.redis_url)
+      end
+
+      # Attempt to consume tokens. Returns true if allowed, false if rate-limited.
+      def consume!(tokens: 1)
+        key       = redis_key
+        now       = Time.now.to_f
+        window_start = now - WINDOW_SECONDS
+
+        # Redis pipeline: count tokens used in current window + add new entry
+        used = @redis.multi do |pipeline|
+          pipeline.zremrangebyscore(key, "-inf", window_start)
+          pipeline.zadd(key, now, "#{now}:#{tokens}")
+          pipeline.zrange(key, 0, -1)
+          pipeline.expire(key, WINDOW_SECONDS * 2)
+        end
+
+        # Tally tokens from sorted set entries
+        entries = used[2] || []
+        total_used = entries.sum do |entry|
+          entry.split(":").last.to_i
+        end
+
+        if total_used > @capacity
+          # Roll back the zadd we just did
+          @redis.zrem(key, "#{now}:#{tokens}")
+          return false
+        end
+
+        true
+      end
+
+      def retry_after
+        # Time until oldest entry expires
+        oldest = @redis.zrange(redis_key, 0, 0, with_scores: true).first
+        return 0 unless oldest
+
+        oldest_time = oldest[1]
+        remaining = (oldest_time + WINDOW_SECONDS) - Time.now.to_f
+        [remaining.ceil, 0].max
+      end
+
+      private
+
+      def redis_key
+        "llm_token_bucket:#{@user_id}"
+      end
+    end
+  end
+end

package/templates/stacks/ruby-rails-8/app/llm/validators/summarize_output_schema.json

@@ -1,21 +1,21 @@
-{
-  "$schema": "http://json-schema.org/draft-07/schema#",
-  "title": "SummarizeOutput",
-  "description": "Schema for LLM summarize operation output",
-  "type": "object",
-  "required": ["summary"],
-  "properties": {
-    "summary": {
-      "type": "string",
-      "minLength": 10,
-      "maxLength": 2000,
-      "description": "The summarized text"
-    },
-    "word_count": {
-      "type": "integer",
-      "minimum": 1,
-      "description": "Optional word count of the summary"
-    }
-  },
-  "additionalProperties": false
-}
+{
+  "$schema": "http://json-schema.org/draft-07/schema#",
+  "title": "SummarizeOutput",
+  "description": "Schema for LLM summarize operation output",
+  "type": "object",
+  "required": ["summary"],
+  "properties": {
+    "summary": {
+      "type": "string",
+      "minLength": 10,
+      "maxLength": 2000,
+      "description": "The summarized text"
+    },
+    "word_count": {
+      "type": "integer",
+      "minimum": 1,
+      "description": "Optional word count of the summary"
+    }
+  },
+  "additionalProperties": false
+}

package/templates/stacks/ruby-rails-8/app/llm/validators/validator.rb

@@ -1,52 +1,52 @@
-# frozen_string_literal: true
-
-# DARE v3.0 — LLM Output Validator
-# Validates LLM responses against JSON Schema definitions
-# Schemas live in app/llm/validators/*.json
-#
-# Usage:
-#   LLM::Validators::Validator.validate!("summarize_output", response_hash)
-
-module LLM
-  module Validators
-    class Validator
-      SCHEMAS_DIR = Rails.root.join("app", "llm", "validators")
-
-      class ValidationError < StandardError
-        attr_reader :errors
-
-        def initialize(schema_name, errors)
-          @errors = errors
-          super("LLM output failed validation for '#{schema_name}': #{errors.map { |e| e[:error] }.join(", ")}")
-        end
-      end
-
-      # Validate a hash against a named JSON Schema.
-      # Raises ValidationError if invalid.
-      def self.validate!(schema_name, data)
-        schema = load_schema!(schema_name)
-        validator = JSONSchemer.schema(schema)
-        errors = validator.validate(data).to_a
-
-        raise ValidationError.new(schema_name, errors) if errors.any?
-
-        true
-      end
-
-      # Returns true/false without raising
-      def self.valid?(schema_name, data)
-        validate!(schema_name, data)
-        true
-      rescue ValidationError
-        false
-      end
-
-      private_class_method def self.load_schema!(name)
-        path = SCHEMAS_DIR.join("#{name}.json")
-        raise ArgumentError, "Schema not found: #{name}.json in #{SCHEMAS_DIR}" unless path.exist?
-
-        JSON.parse(path.read)
-      end
-    end
-  end
-end
+# frozen_string_literal: true
+
+# DARE v3.0 — LLM Output Validator
+# Validates LLM responses against JSON Schema definitions
+# Schemas live in app/llm/validators/*.json
+#
+# Usage:
+#   LLM::Validators::Validator.validate!("summarize_output", response_hash)
+
+module LLM
+  module Validators
+    class Validator
+      SCHEMAS_DIR = Rails.root.join("app", "llm", "validators")
+
+      class ValidationError < StandardError
+        attr_reader :errors
+
+        def initialize(schema_name, errors)
+          @errors = errors
+          super("LLM output failed validation for '#{schema_name}': #{errors.map { |e| e[:error] }.join(", ")}")
+        end
+      end
+
+      # Validate a hash against a named JSON Schema.
+      # Raises ValidationError if invalid.
+      def self.validate!(schema_name, data)
+        schema = load_schema!(schema_name)
+        validator = JSONSchemer.schema(schema)
+        errors = validator.validate(data).to_a
+
+        raise ValidationError.new(schema_name, errors) if errors.any?
+
+        true
+      end
+
+      # Returns true/false without raising
+      def self.valid?(schema_name, data)
+        validate!(schema_name, data)
+        true
+      rescue ValidationError
+        false
+      end
+
+      private_class_method def self.load_schema!(name)
+        path = SCHEMAS_DIR.join("#{name}.json")
+        raise ArgumentError, "Schema not found: #{name}.json in #{SCHEMAS_DIR}" unless path.exist?
+
+        JSON.parse(path.read)
+      end
+    end
+  end
+end