@dewtech/dare-cli 2.17.0 → 3.1.0

package/templates/stacks/python-fastapi/pyproject.toml.j2

@@ -0,0 +1,45 @@
+[project]
+name = "{{ projectName }}"
+version = "0.1.0"
+description = "DARE-shaped FastAPI API"
+requires-python = ">=3.11"
+dependencies = [
+    "fastapi>=0.115,<1.0",
+    "uvicorn[standard]>=0.30,<1.0",
+    "pydantic[email]>=2.7,<3.0",
+    "pydantic-settings>=2.4,<3.0",
+    "sqlalchemy>=2.0,<3.0",
+    "alembic>=1.13,<2.0",
+    "psycopg[binary]>=3.2,<4.0",
+    "python-jose[cryptography]>=3.3,<4.0",
+    "passlib[bcrypt]>=1.7,<2.0",
+    "slowapi>=0.1.9,<0.2.0",
+    "python-multipart>=0.0.9",
+]
+
+[project.optional-dependencies]
+dev = [
+    "pytest>=8.2,<9.0",
+    "pytest-asyncio>=0.23,<1.0",
+    "httpx>=0.27,<1.0",
+    "ruff>=0.5,<1.0",
+    "pip-audit>=2.7,<3.0",
+]
+
+[build-system]
+requires = ["hatchling"]
+build-backend = "hatchling.build"
+
+[tool.hatch.build.targets.wheel]
+packages = ["app"]
+
+[tool.ruff]
+line-length = 100
+target-version = "py311"
+
+[tool.ruff.lint]
+select = ["E", "F", "I", "B", "UP"]
+ignore = ["E501"]
+
+[tool.pytest.ini_options]
+asyncio_mode = "auto"

package/templates/stacks/python-fastapi/tests/test_auth.py

@@ -0,0 +1,22 @@
+"""Smoke tests for auth router using httpx + FastAPI's TestClient."""
+from fastapi.testclient import TestClient
+
+from app.main import app
+
+client = TestClient(app)
+
+
+def test_healthz_returns_ok() -> None:
+    res = client.get("/healthz")
+    assert res.status_code == 200
+    assert res.json() == {"status": "ok"}
+
+
+def test_login_rejects_bad_email() -> None:
+    res = client.post("/auth/login", json={"email": "not-an-email", "password": "Str0ngPass"})
+    assert res.status_code == 422
+
+
+def test_login_rejects_short_password() -> None:
+    res = client.post("/auth/login", json={"email": "u@example.com", "password": "short"})
+    assert res.status_code == 422

package/templates/stacks/ruby-rails-8/.dare/skills.yml

@@ -0,0 +1,50 @@
+# DARE v3.0 — Skills manifest
+# Lists which DARE skills are active in this project.
+# Used by: dare validate, rake dare:metrics, CI checks
+
+version: "3.0"
+stack: ruby-rails-8
+
+skills:
+  dare-ax:
+    version: "1.0"
+    enabled: true
+    artifacts:
+      - llms.txt
+      - public/openapi.json
+
+  dare-layered-design:
+    version: "1.0"
+    enabled: true
+    directories:
+      - app/handlers
+      - app/services
+      - app/repositories
+      - app/models
+      - app/presenters
+
+  dare-llm-integration:
+    version: "1.0"
+    enabled: true
+    directories:
+      - app/llm/providers
+      - app/llm/prompts
+      - app/llm/validators
+      - app/llm/cache
+      - app/llm/rate_limit
+
+  dare-realtime:
+    version: "1.0"
+    enabled: true
+    directories:
+      - app/channels
+
+  dare-quality-telemetry:
+    version: "1.0"
+    enabled: true
+    rake_task: dare:metrics
+    metrics:
+      - M-01  # llms.txt exists
+      - M-02  # OpenAPI spec exists
+      - M-03  # CLI --json support
+      - M-04  # Rate limiting configured

package/templates/stacks/ruby-rails-8/.env.example

@@ -0,0 +1,20 @@
+# Application
+RAILS_ENV=development
+PORT=3000
+LOG_LEVEL=info
+
+# Database
+DATABASE_URL=postgresql://user:pass@localhost:5432/myapp_development
+
+# Rails master key lives in config/master.key (NOT here) — never commit it.
+# SECRET_KEY_BASE is derived from credentials in production.
+
+# Action Cable / Redis
+REDIS_URL=redis://localhost:6379/1
+
+# Rate limit (rack-attack)
+RATE_LIMIT_PER_MIN=60
+
+# LLM provider (optional)
+LLM_PROVIDER=dummy
+# OPENAI_API_KEY=

package/templates/stacks/ruby-rails-8/.github/workflows/dare-ci.yml

@@ -0,0 +1,112 @@
+# DARE v3.1 — CI/CD Pipeline for Rails 8 stack
+# Runs on every push and pull_request
+# Validates: bundle audit + rubocop + rspec + dare:metrics (M-01 to M-04)
+
+name: DARE CI
+
+on:
+  push:
+    branches: ["**"]
+  pull_request:
+    branches: ["**"]
+
+jobs:
+  audit:
+    name: Audit dependencies
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v4
+      - uses: ruby/setup-ruby@v1
+        with:
+          ruby-version: "3.3"
+          bundler-cache: true
+      - name: bundle audit
+        run: |
+          gem install bundler-audit
+          bundle audit check --update
+
+  lint:
+    name: Lint (RuboCop)
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v4
+      - uses: ruby/setup-ruby@v1
+        with:
+          ruby-version: "3.3"
+          bundler-cache: true
+      - name: rubocop
+        run: bundle exec rubocop
+
+  test:
+    name: Test (Ruby ${{ matrix.ruby }})
+    runs-on: ubuntu-latest
+
+    strategy:
+      fail-fast: false
+      matrix:
+        ruby: ["3.3"]
+
+    services:
+      postgres:
+        image: postgres:14
+        env:
+          POSTGRES_USER:     postgres
+          POSTGRES_PASSWORD: postgres
+          POSTGRES_DB:       app_test
+        options: >-
+          --health-cmd pg_isready
+          --health-interval 10s
+          --health-timeout 5s
+          --health-retries 5
+        ports:
+          - 5432:5432
+
+      redis:
+        image: redis:7
+        options: >-
+          --health-cmd "redis-cli ping"
+          --health-interval 10s
+          --health-timeout 5s
+          --health-retries 5
+        ports:
+          - 6379:6379
+
+    env:
+      RAILS_ENV:    test
+      DATABASE_URL: postgres://postgres:postgres@localhost:5432/app_test
+      REDIS_URL:    redis://localhost:6379/0
+      RAILS_MASTER_KEY: ${{ secrets.RAILS_MASTER_KEY }}
+
+    steps:
+      - name: Checkout code
+        uses: actions/checkout@v4
+
+      - name: Set up Ruby ${{ matrix.ruby }}
+        uses: ruby/setup-ruby@v1
+        with:
+          ruby-version: ${{ matrix.ruby }}
+          bundler-cache: true
+
+      - name: Set up database
+        run: bundle exec rails db:create db:migrate RAILS_ENV=test
+
+      - name: Run RSpec
+        run: bundle exec rspec --format progress --format RspecJunitFormatter --out tmp/rspec.xml
+        continue-on-error: false
+
+      - name: Run DARE metrics validation
+        run: bundle exec rake dare:metrics
+
+      - name: Upload test results
+        if: always()
+        uses: actions/upload-artifact@v4
+        with:
+          name: rspec-results
+          path: tmp/rspec.xml
+
+      - name: Upload DARE metrics
+        if: always()
+        uses: actions/upload-artifact@v4
+        with:
+          name: dare-metrics
+          path: tmp/dare_metrics.json

package/templates/stacks/ruby-rails-8/Gemfile.erb

@@ -0,0 +1,61 @@
+# frozen_string_literal: true
+
+source "https://rubygems.org"
+
+ruby ">= 3.3.0"
+
+# Core — Rails 8 Omakase
+gem "rails", "~> 8.0"
+gem "puma", ">= 5.0"
+gem "bootsnap", require: false
+gem "tzinfo-data", platforms: %i[windows jruby]
+
+# Database
+gem "pg", "~> 1.1"
+
+# Solid Suite (Rails 8 Omakase)
+gem "solid_cache"
+gem "solid_queue"
+
+# Real-time
+gem "redis", "~> 5.0"
+gem "redis-actioncable", require: false
+
+# OpenAPI — single source of truth via rswag
+gem "rswag-api"
+gem "rswag-ui"
+
+# Rate limiting
+gem "rack-attack"
+
+# JSON Schema validation
+gem "json_schemer"
+
+# HTTP client for LLM providers
+gem "faraday", "~> 2.0"
+gem "faraday-retry"
+
+# Background processing
+gem "solid_queue"
+
+group :development, :test do
+  gem "debug", platforms: %i[mri windows linux]
+  gem "rspec-rails", "~> 6.0"
+  gem "factory_bot_rails", "~> 6.0"
+  gem "faker", "~> 3.0"
+  gem "rswag-specs"
+  gem "shoulda-matchers", "~> 5.0"
+  gem "simplecov", require: false
+end
+
+group :development do
+  gem "web-console"
+  gem "rack-mini-profiler"
+  gem "rubocop-rails-omakase", require: false
+end
+
+group :test do
+  gem "database_cleaner-active_record"
+  gem "webmock"
+  gem "vcr"
+end

package/templates/stacks/ruby-rails-8/app/channels/application_cable/channel.rb

@@ -0,0 +1,11 @@
+# frozen_string_literal: true
+
+# DARE v3.0 — ApplicationCable::Channel base
+# All channels inherit from this; subscription authorization happens here
+
+module ApplicationCable
+  class Channel < ActionCable::Channel::Base
+    # Convenience: access current_user from connection in all channels
+    delegate :current_user, to: :connection
+  end
+end

package/templates/stacks/ruby-rails-8/app/channels/application_cable/connection.rb

@@ -0,0 +1,34 @@
+# frozen_string_literal: true
+
+# DARE v3.0 — Action Cable Connection with cookie-based auth
+# Convention (ADR-03): Every connection validates authentication
+# Unauthorized connections are rejected at the connection level
+
+module ApplicationCable
+  class Connection < ActionCable::Connection::Base
+    identified_by :current_user
+
+    def connect
+      self.current_user = find_verified_user
+    end
+
+    private
+
+    def find_verified_user
+      # Strategy 1: cookie-based session (most common for Rails apps)
+      if (user_id = cookies.signed[:user_id])
+        user = User.find_by(id: user_id)
+        return user if user&.active?
+      end
+
+      # Strategy 2: token-based (for mobile/API clients)
+      if (token = request.params[:token].presence || env["HTTP_X_ACTION_CABLE_TOKEN"])
+        # Implement your token lookup here:
+        # user = User.find_by_auth_token(token)
+        # return user if user&.active?
+      end
+
+      reject_unauthorized_connection
+    end
+  end
+end

package/templates/stacks/ruby-rails-8/app/channels/dare_updates_channel.rb

@@ -0,0 +1,18 @@
+# frozen_string_literal: true
+
+# DARE v3.0 — DareUpdatesChannel
+# Convention (ADR-03): subscriptions authorize before streaming
+# This is a generic channel for DARE system events (metrics, deploys, etc.)
+
+class DareUpdatesChannel < ApplicationCable::Channel
+  def subscribed
+    # Reject if not authenticated (connection already checks, but belt-and-suspenders)
+    reject_subscription unless current_user
+
+    stream_from "dare_updates:#{current_user.id}"
+  end
+
+  def unsubscribed
+    stop_all_streams
+  end
+end

package/templates/stacks/ruby-rails-8/app/channels/user_updates_channel.rb

@@ -0,0 +1,23 @@
+# frozen_string_literal: true
+
+# DARE v3.0 — UserUpdatesChannel
+# Convention (ADR-03): per-user channel with authorization check
+# Frontend subscribes with: consumer.subscriptions.create({ channel: "UserUpdatesChannel", user_id: 123 })
+
+class UserUpdatesChannel < ApplicationCable::Channel
+  def subscribed
+    user_id = params[:user_id].to_i
+
+    # Authorization: only subscribe to your own updates (or admin)
+    unless current_user.can_view?(user_id)
+      reject_subscription
+      return
+    end
+
+    stream_for user_id
+  end
+
+  def unsubscribed
+    stop_all_streams
+  end
+end

package/templates/stacks/ruby-rails-8/app/controllers/application_controller.rb

@@ -0,0 +1,44 @@
+# frozen_string_literal: true
+
+# DARE v3.0 — ApplicationController
+# - CSRF protection active (RS-01)
+# - RFC 7807 Problem Details included (D-006)
+# - Thin controller: HTTP concerns only, delegates to Services
+
+class ApplicationController < ActionController::API
+  include ProblemDetails
+
+  # Enforce JSON responses for all API endpoints
+  before_action :set_default_response_format
+
+  private
+
+  def set_default_response_format
+    request.format = :json
+  end
+
+  # Override in specific controllers if authentication is needed
+  def current_user
+    @current_user ||= authenticate_user_from_token
+  end
+
+  def authenticate_user_from_token
+    token = request.headers["Authorization"]&.sub(/\ABearer /, "")
+    return nil unless token
+
+    # TODO: implement your token strategy here (JWT, session, etc.)
+    # User.find_by_token(token)
+    nil
+  end
+
+  def require_authentication!
+    return if current_user
+
+    render_problem(
+      status: :unauthorized,
+      title:  "Unauthorized",
+      detail: "You must be authenticated to access this resource.",
+      type:   "https://developer.mozilla.org/en-US/docs/Web/HTTP/Status/401"
+    )
+  end
+end

package/templates/stacks/ruby-rails-8/app/controllers/concerns/problem_details.rb

@@ -0,0 +1,93 @@
+# frozen_string_literal: true
+
+# DARE v3.0 — RFC 7807 Problem Details concern
+# Decision: D-006 — all HTTP errors use this format
+#
+# Usage: include ProblemDetails in ApplicationController
+#
+# Format:
+#   {
+#     "type":     "https://example.com/problems/not-found",
+#     "title":    "Resource Not Found",
+#     "status":   404,
+#     "detail":   "User with id=42 was not found.",
+#     "instance": "/api/users/42"
+#   }
+
+module ProblemDetails
+  extend ActiveSupport::Concern
+
+  included do
+    rescue_from StandardError,                    with: :render_internal_error
+    rescue_from ActiveRecord::RecordNotFound,     with: :render_not_found
+    rescue_from ActiveRecord::RecordInvalid,      with: :render_unprocessable_entity
+    rescue_from ActionController::ParameterMissing, with: :render_bad_request
+    rescue_from ArgumentError,                    with: :render_bad_request
+  end
+
+  # ── Public helpers ──────────────────────────────────────────────────────────
+
+  # Render a Problem Details response manually.
+  #
+  #   render_problem(status: :not_found, title: "User Not Found", detail: "...")
+  def render_problem(status:, title:, detail: nil, type: nil, **extra)
+    http_status = Rack::Utils.status_code(status)
+
+    body = {
+      type:     type || default_type_uri(http_status),
+      title:    title,
+      status:   http_status,
+      detail:   detail,
+      instance: request.path,
+    }.merge(extra).compact
+
+    render json: body,
+           status: http_status,
+           content_type: "application/problem+json"
+  end
+
+  private
+
+  def render_not_found(exception)
+    render_problem(
+      status: :not_found,
+      title:  "Not Found",
+      detail: exception.message.presence || "The requested resource does not exist."
+    )
+  end
+
+  def render_unprocessable_entity(exception)
+    errors = exception.record&.errors&.full_messages || [exception.message]
+    render_problem(
+      status:  :unprocessable_entity,
+      title:   "Validation Failed",
+      detail:  "One or more fields failed validation.",
+      errors:  errors
+    )
+  end
+
+  def render_bad_request(exception)
+    render_problem(
+      status: :bad_request,
+      title:  "Bad Request",
+      detail: exception.message
+    )
+  end
+
+  def render_internal_error(exception)
+    # Never leak internals in production
+    detail = Rails.env.production? ? "An unexpected error occurred." : exception.message
+
+    Rails.logger.error "[ProblemDetails] #{exception.class}: #{exception.message}\n#{exception.backtrace&.first(10)&.join("\n")}"
+
+    render_problem(
+      status: :internal_server_error,
+      title:  "Internal Server Error",
+      detail: detail
+    )
+  end
+
+  def default_type_uri(status_code)
+    "https://developer.mozilla.org/en-US/docs/Web/HTTP/Status/#{status_code}"
+  end
+end

package/templates/stacks/ruby-rails-8/app/handlers/summarize_handler.rb

@@ -0,0 +1,33 @@
+# frozen_string_literal: true
+
+# DARE v3.0 — SummarizeHandler (thin controller, delegates to service)
+# Convention (ADR-01): HTTP concerns only — params, response codes, delegation
+# No business logic here.
+#
+# POST /api/v1/documents/:id/summarize
+# RFC 7807 errors via ProblemDetails concern (D-006)
+
+class SummarizeHandler < ApplicationController
+  include ProblemDetails
+
+  before_action :authenticate_user!  # assume Devise or similar
+
+  # POST /api/v1/documents/:id/summarize
+  def create
+    result = Services::SummarizeDocumentService.new(
+      document_repository: Repositories::DocumentRepository.new,
+      llm_provider:        LLM::Providers::LLMProvider.instance,
+      event_publisher:     RealtimeService.instance
+    ).execute(
+      document_id: params[:id],
+      user_id:     current_user.id
+    )
+
+    render json: { summary: result.summary, document_id: result.document_id }, status: :ok
+
+  rescue Services::SummarizeDocumentService::DocumentNotFoundError => e
+    render_problem(status: 404, title: "Not Found", detail: e.message)
+  rescue Services::SummarizeDocumentService::SummarizationError => e
+    render_problem(status: 422, title: "Summarization Failed", detail: e.message)
+  end
+end

package/templates/stacks/ruby-rails-8/app/handlers/users_handler.rb

@@ -0,0 +1,68 @@
+# frozen_string_literal: true
+
+# DARE v3.0 — UsersHandler (thin controller)
+# Convention (ADR-01): HTTP concerns only — params, response codes, delegation
+# No business logic, no repository calls, no queries here.
+
+class UsersHandler < ApplicationController
+  before_action :require_authentication!, only: %i[update destroy]
+
+  # GET /api/users
+  def index
+    repo  = Repositories::UserRepository.new
+    users = repo.all_active
+
+    render json: UserPresenter.collection(users), status: :ok
+  end
+
+  # GET /api/users/:id
+  def show
+    repo = Repositories::UserRepository.new
+    user = repo.find!(params[:id])
+
+    render json: UserPresenter.new(user).as_json, status: :ok
+  end
+
+  # POST /api/users
+  def create
+    input = params.require(:user).permit(:email, :name, :password)
+
+    user = Services::CreateUserService.new(
+      user_repository: Repositories::UserRepository.new,
+      event_publisher: RealtimeService.instance
+    ).execute(
+      email:    input[:email],
+      name:     input[:name],
+      password: input[:password]
+    )
+
+    render json: UserPresenter.new(user).as_json, status: :created
+
+  rescue Services::CreateUserService::EmailTakenError => e
+    render_problem(
+      status: :conflict,
+      title:  "Email Already Taken",
+      detail: e.message
+    )
+  end
+
+  # PATCH /api/users/:id
+  def update
+    repo  = Repositories::UserRepository.new
+    user  = repo.find!(params[:id])
+    input = params.require(:user).permit(:name)
+
+    repo.update!(user, input.to_h)
+
+    render json: UserPresenter.new(user).as_json, status: :ok
+  end
+
+  # DELETE /api/users/:id
+  def destroy
+    repo = Repositories::UserRepository.new
+    user = repo.find!(params[:id])
+    repo.destroy!(user)
+
+    head :no_content
+  end
+end

package/templates/stacks/ruby-rails-8/app/llm/cache/llm_cache.rb

@@ -0,0 +1,44 @@
+# frozen_string_literal: true
+
+# DARE v3.0 — LLM Cache (Redis wrapper)
+# Caches LLM responses to reduce API costs and latency
+# Uses SHA256 of (model + prompt) as cache key
+#
+# Usage:
+#   result = LLM::Cache::LlmCache.instance.fetch(model: "gpt-4o", prompt: prompt) do
+#     LLMProvider.instance.complete(model: "gpt-4o", prompt: prompt)
+#   end
+
+module LLM
+  module Cache
+    class LlmCache
+      include Singleton
+
+      DEFAULT_TTL = 24.hours
+
+      def fetch(model:, prompt:, ttl: DEFAULT_TTL, &block)
+        key = cache_key(model, prompt)
+
+        Rails.cache.fetch(key, expires_in: ttl, &block)
+      end
+
+      def invalidate(model:, prompt:)
+        key = cache_key(model, prompt)
+        Rails.cache.delete(key)
+      end
+
+      def clear_all!
+        # WARNING: clears entire Rails cache — use only in test/dev
+        raise "clear_all! not allowed in production!" if Rails.env.production?
+        Rails.cache.clear
+      end
+
+      private
+
+      def cache_key(model, prompt)
+        hash = Digest::SHA256.hexdigest("#{model}:#{prompt}")
+        "llm_cache:#{hash}"
+      end
+    end
+  end
+end