@dewtech/dare-cli 3.0.0 → 3.2.0

package/templates/stacks/ruby-rails-8/lib/tasks/dare.rake

@@ -0,0 +1,159 @@
+# frozen_string_literal: true
+
+# DARE v3.0 — Quality Telemetry rake tasks
+# Validates conformance metrics M-01 to M-04 as per dare-quality-telemetry spec
+#
+# Usage:
+#   bundle exec rake dare:metrics         # Full validation + JSON output
+#   bundle exec rake dare:metrics:quick   # Exit-only (CI-friendly)
+#   bundle exec rake dare:openapi         # Regenerate OpenAPI spec
+#
+# CI integration: add `bundle exec rake dare:metrics` to your CI pipeline.
+# The task exits with code 1 if any metric fails.
+
+namespace :dare do
+  # ── Main metrics validation task ─────────────────────────────────────────
+  desc "Validate DARE conformance metrics M-01 to M-04 and output JSON report"
+  task metrics: :environment do
+    require "json"
+
+    results = {
+      timestamp:   Time.now.iso8601,
+      commit:      git_commit_sha,
+      stack:       "ruby-rails-8",
+      dare_version: "3.0",
+      metrics:     {}
+    }
+
+    # M-01: llms.txt exists and is non-empty
+    llms_txt_path = Rails.root.join("llms.txt")
+    llms_txt_valid = llms_txt_path.exist? && llms_txt_path.size > 0
+    results[:metrics]["M-01"] = {
+      pass:        llms_txt_valid,
+      description: "Project has valid llms.txt",
+      details:     llms_txt_valid ? "llms.txt found (#{llms_txt_path.size} bytes)" : "llms.txt missing or empty"
+    }
+
+    # M-02: OpenAPI spec exists and is valid JSON
+    openapi_path = Rails.root.join("public", "openapi.json")
+    openapi_valid = begin
+      openapi_path.exist? && JSON.parse(openapi_path.read).is_a?(Hash)
+    rescue JSON::ParserError
+      false
+    end
+    results[:metrics]["M-02"] = {
+      pass:        openapi_valid,
+      description: "All endpoints have OpenAPI documentation",
+      details:     openapi_valid ? "public/openapi.json found and valid" : "public/openapi.json missing or invalid JSON"
+    }
+
+    # M-03: CLI --json support (rails --help or dare:metrics itself)
+    # The DARE rails stack exposes JSON output from rake dare:metrics
+    cli_json_support = true  # This task itself emits JSON — M-03 is satisfied
+    results[:metrics]["M-03"] = {
+      pass:        cli_json_support,
+      description: "CLI supports --json output",
+      details:     "rake dare:metrics emits JSON via STDOUT. Pass DARE_JSON=1 for machine-readable only."
+    }
+
+    # M-04: Rate limiting configured (rack-attack initializer present)
+    rack_attack_path = Rails.root.join("config", "initializers", "rack_attack.rb")
+    rate_limit_configured = rack_attack_path.exist?
+    results[:metrics]["M-04"] = {
+      pass:        rate_limit_configured,
+      description: "100% of public endpoints have rate limit configured",
+      details:     rate_limit_configured ? "rack_attack.rb initializer found" : "config/initializers/rack_attack.rb missing"
+    }
+
+    # ── Summary ─────────────────────────────────────────────────────────────
+    all_passed = results[:metrics].all? { |_, m| m[:pass] }
+    passed_count = results[:metrics].count { |_, m| m[:pass] }
+    total_count  = results[:metrics].size
+
+    results[:summary] = {
+      passed:    passed_count,
+      total:     total_count,
+      all_pass:  all_passed,
+      score:     "#{(passed_count.to_f / total_count * 100).round(1)}%"
+    }
+
+    # ── Output ───────────────────────────────────────────────────────────────
+    json_output = JSON.pretty_generate(results)
+    puts json_output
+
+    # Save to tmp/dare_metrics.json
+    tmp_dir = Rails.root.join("tmp")
+    FileUtils.mkdir_p(tmp_dir)
+    File.write(Rails.root.join("tmp", "dare_metrics.json"), json_output)
+    $stderr.puts "\n[DARE] Metrics saved to tmp/dare_metrics.json" unless ENV["DARE_JSON"]
+
+    unless all_passed
+      $stderr.puts "\n[DARE] FAILED: #{total_count - passed_count} metric(s) not passing.\n"
+      $stderr.puts results[:metrics].select { |_, m| !m[:pass] }.map { |k, m| "  #{k}: #{m[:details]}" }.join("\n")
+      exit!(1)
+    end
+
+    $stderr.puts "\n[DARE] All #{total_count} metrics passed (#{results[:summary][:score]})\n" unless ENV["DARE_JSON"]
+  end
+
+  # ── Quick check for CI pipelines ─────────────────────────────────────────
+  namespace :metrics do
+    desc "Quick DARE metrics check (silent — exit code only)"
+    task quick: :environment do
+      ENV["DARE_JSON"] = "1"
+      Rake::Task["dare:metrics"].invoke
+    end
+  end
+
+  # ── OpenAPI regeneration ──────────────────────────────────────────────────
+  desc "Regenerate public/openapi.json from rswag specs"
+  task openapi: :environment do
+    puts "[DARE] Regenerating OpenAPI spec via rswag..."
+
+    # rswag generates the spec when you run rswag:specs:swaggerize
+    # This is a convenience wrapper
+    Rake::Task["rswag:specs:swaggerize"].invoke if Rake::Task.task_defined?("rswag:specs:swaggerize")
+
+    openapi_path = Rails.root.join("public", "openapi.json")
+    if openapi_path.exist?
+      puts "[DARE] OpenAPI spec generated: #{openapi_path}"
+    else
+      warn "[DARE] WARNING: public/openapi.json not found after swaggerize."
+      warn "[DARE] Run: bundle exec rspec spec/api/ to generate it."
+    end
+  end
+
+  # ── Validate layered design ───────────────────────────────────────────────
+  desc "Validate DARE layered design directory structure"
+  task validate_structure: :environment do
+    required_dirs = %w[
+      app/handlers
+      app/services
+      app/repositories
+      app/models
+      app/presenters
+      app/llm/providers
+      app/llm/prompts
+      app/llm/validators
+      app/channels
+    ]
+
+    missing = required_dirs.reject { |d| Rails.root.join(d).exist? }
+
+    if missing.any?
+      warn "[DARE] Missing directories:"
+      missing.each { |d| warn "  - #{d}" }
+      exit!(1)
+    else
+      puts "[DARE] Layered design structure OK (#{required_dirs.size} directories)"
+    end
+  end
+
+  private
+
+  def git_commit_sha
+    `git rev-parse --short HEAD 2>/dev/null`.strip.presence || "unknown"
+  rescue StandardError
+    "unknown"
+  end
+end

package/templates/stacks/ruby-rails-8/llms.txt.erb

@@ -0,0 +1,69 @@
+# llms.txt — Project Context for AI Agents
+# Generated by DARE v3.0 — ruby-rails-8 stack
+# App: <%= app_name %>
+
+## Project Overview
+Rails 8 application built with DARE v3.0 methodology.
+Stack: ruby-rails-8 | Layered Design | OpenAPI | LLM integration | Action Cable
+
+## Tech Stack
+- Language: Ruby 3.3+
+- Framework: Rails 8.0+ (Omakase)
+- Database: PostgreSQL 14+
+- Real-time: Action Cable + Redis
+- Background: Solid Queue
+- Cache: Solid Cache + Redis
+- Deploy: Kamal
+
+## Architecture (Layered Design)
+- app/handlers/    — HTTP handlers (thin controllers — only HTTP concerns)
+- app/services/    — Business logic (one class per operation, pure Ruby)
+- app/repositories/ — Data access (interface + ActiveRecord implementation)
+- app/models/      — Domain objects (no callbacks, no fat model)
+- app/presenters/  — Serializers (Model → JSON, RFC 7807 errors)
+- app/llm/         — LLM patterns (providers, prompts, validators, cache)
+- app/channels/    — Real-time (Action Cable, authorized subscriptions)
+- app/jobs/        — Background jobs (Solid Queue)
+
+## Key Conventions
+- Controllers NEVER call Repository or contain business logic
+- Services are plain Ruby objects injected with dependencies
+- Repositories abstract ActiveRecord; services never call AR directly
+- Errors always formatted as RFC 7807 Problem Details
+- Every endpoint documented via rswag (OpenAPI auto-generated from specs)
+
+## Key Endpoints
+- GET  /openapi.json          — OpenAPI spec (auto-generated by rswag)
+- GET  /api-docs              — Swagger UI
+- POST /api/users             — Create user (example)
+- GET  /api/users/:id         — Show user (example)
+
+## Getting Started
+bundle install
+bin/rails db:create db:migrate
+bin/rails server
+# OR with Kamal:
+kamal setup && kamal deploy
+
+## Rate Limits
+- Public endpoints:   100 req/min per IP  (rack-attack)
+- Auth endpoints:      10 req/min per IP
+- LLM endpoints:       20 req/min per user
+
+## For AI Agents
+- OpenAPI spec:    GET /openapi.json
+- DARE metrics:    bundle exec rake dare:metrics
+- Test suite:      bundle exec rspec
+- Lint:            bundle exec rubocop
+- Rails help:      bin/rails --help
+- DARE manifest:   .dare/skills.yml
+
+## Directory Guide
+- New feature? Add: handler → service → repository → model → presenter → spec
+- New LLM feature? Add provider/prompt/validator in app/llm/
+- New real-time event? Add channel in app/channels/ + realtime_service.rb broadcast
+- New background job? Add in app/jobs/ using Solid Queue
+
+## Generated by
+DARE Method v3.0 — https://github.com/dewtech-technologies/dare-method
+Stack: ruby-rails-8

package/templates/stacks/ruby-rails-8/spec/api/summarize_spec.rb

@@ -0,0 +1,56 @@
+# frozen_string_literal: true
+
+# DARE v3.0 — rswag OpenAPI spec for Summarize Documents API
+# M-02: running `rake rswag:specs:swaggerize` generates public/openapi.json from this
+require "swagger_helper"
+
+RSpec.describe "Summarize Documents API", type: :request do
+  path "/api/v1/documents/{id}/summarize" do
+    parameter name: :id, in: :path, type: :string, description: "Document ID"
+
+    post "Summarize a document with LLM" do
+      tags        "Documents"
+      produces    "application/json"
+      security    [{ bearerAuth: [] }]
+      description <<~DESC
+        Summarizes the document identified by :id using the configured LLM provider.
+        Returns the generated summary and the document ID on success.
+        RFC 7807 Problem Details on errors (D-006).
+      DESC
+
+      response "200", "Document summarized successfully" do
+        schema type: :object,
+               required: %w[summary document_id],
+               properties: {
+                 summary:     { type: :string, example: "This document discusses..." },
+                 document_id: { type: :string, example: "doc-abc-123" }
+               }
+
+        let(:id) { create(:document, content: "Long content to summarize.").id }
+        run_test!
+      end
+
+      response "401", "Unauthorized — missing or invalid authentication token" do
+        schema "$ref" => "#/components/schemas/ProblemDetails"
+
+        let(:id) { "any-id" }
+        # No auth header provided
+        run_test!
+      end
+
+      response "404", "Document not found" do
+        schema "$ref" => "#/components/schemas/ProblemDetails"
+
+        let(:id) { "non-existent-document-id" }
+        run_test!
+      end
+
+      response "422", "Summarization failed (LLM returned empty result)" do
+        schema "$ref" => "#/components/schemas/ProblemDetails"
+
+        let(:id) { create(:document, content: "").id }
+        run_test!
+      end
+    end
+  end
+end

package/templates/stacks/ruby-rails-8/spec/api/users_spec.rb

@@ -0,0 +1,72 @@
+# frozen_string_literal: true
+
+# DARE v3.0 — rswag OpenAPI spec for Users API
+# M-02: running `rake rswag:specs:swaggerize` generates public/openapi.json from this
+require "swagger_helper"
+
+RSpec.describe "Users API", type: :request do
+  path "/api/users" do
+    post "Create a user" do
+      tags        "Users"
+      consumes    "application/json"
+      produces    "application/json"
+      description "Creates a new user. Returns 201 on success, 409 if email already taken."
+
+      parameter name: :user, in: :body, schema: {
+        type:       :object,
+        required:   %w[email name],
+        properties: {
+          email: { type: :string, example: "alice@example.com" },
+          name:  { type: :string, example: "Alice" }
+        }
+      }
+
+      response "201", "User created successfully" do
+        let(:user) { { email: "new@example.com", name: "New User" } }
+        run_test!
+      end
+
+      response "409", "Email already taken" do
+        schema "$ref" => "#/components/schemas/ProblemDetails"
+        let(:user) { { email: create(:user).email, name: "Dup" } }
+        run_test!
+      end
+
+      response "400", "Missing required parameters" do
+        schema "$ref" => "#/components/schemas/ProblemDetails"
+        let(:user) { {} }
+        run_test!
+      end
+    end
+
+    get "List active users" do
+      tags     "Users"
+      produces "application/json"
+
+      response "200", "Users listed" do
+        before { create_list(:user, 3) }
+        run_test!
+      end
+    end
+  end
+
+  path "/api/users/{id}" do
+    parameter name: :id, in: :path, type: :integer
+
+    get "Show a user" do
+      tags     "Users"
+      produces "application/json"
+
+      response "200", "User found" do
+        let(:id) { create(:user).id }
+        run_test!
+      end
+
+      response "404", "User not found" do
+        schema "$ref" => "#/components/schemas/ProblemDetails"
+        let(:id) { 99_999 }
+        run_test!
+      end
+    end
+  end
+end

package/templates/stacks/ruby-rails-8/spec/channels/dare_updates_channel_spec.rb

@@ -0,0 +1,61 @@
+# frozen_string_literal: true
+
+# DARE v3.0 — DareUpdatesChannel spec
+# Convention (ADR-06): tests auth and subscription behavior
+# Verifies that document.summarized events arrive on the correct channel
+require "rails_helper"
+
+RSpec.describe DareUpdatesChannel, type: :channel do
+  let(:user) { create(:user) }
+
+  describe "#subscribed" do
+    context "when user is authenticated" do
+      before do
+        stub_connection current_user: user
+      end
+
+      it "subscribes successfully" do
+        subscribe
+
+        expect(subscription).to be_confirmed
+      end
+
+      it "streams from the user-scoped dare_updates channel" do
+        subscribe
+
+        expect(streams).to include("dare_updates:#{user.id}")
+      end
+    end
+
+    context "when user is not authenticated" do
+      before do
+        stub_connection current_user: nil
+      end
+
+      it "rejects the subscription" do
+        subscribe
+
+        expect(subscription).to be_rejected
+      end
+    end
+  end
+
+  describe "document.summarized event delivery" do
+    before do
+      stub_connection current_user: user
+    end
+
+    it "delivers document.summarized payload to subscribed user" do
+      subscribe
+
+      expect {
+        ActionCable.server.broadcast(
+          "dare_updates:#{user.id}",
+          { type: "document.summarized", data: { document_id: "doc-1", summary_length: 120 } }
+        )
+      }.to have_broadcasted_to("dare_updates:#{user.id}").with(
+        hash_including(type: "document.summarized")
+      )
+    end
+  end
+end

package/templates/stacks/ruby-rails-8/spec/channels/user_updates_channel_spec.rb

@@ -0,0 +1,56 @@
+# frozen_string_literal: true
+
+# DARE v3.0 — UserUpdatesChannel spec
+# Convention (ADR-06): tests auth and subscription behavior
+require "rails_helper"
+
+RSpec.describe UserUpdatesChannel, type: :channel do
+  let(:user) { create(:user) }
+
+  describe "#subscribed" do
+    context "when user is authenticated and subscribing to their own updates" do
+      before do
+        stub_connection current_user: user
+      end
+
+      it "subscribes successfully" do
+        subscribe user_id: user.id
+
+        expect(subscription).to be_confirmed
+      end
+
+      it "streams for the user" do
+        subscribe user_id: user.id
+
+        expect(streams).to include("user_updates:#{user.id}")
+      end
+    end
+
+    context "when user tries to subscribe to another user's updates without permission" do
+      let(:other_user) { create(:user) }
+
+      before do
+        stub_connection current_user: user
+        allow(user).to receive(:can_view?).with(other_user.id).and_return(false)
+      end
+
+      it "rejects the subscription" do
+        subscribe user_id: other_user.id
+
+        expect(subscription).to be_rejected
+      end
+    end
+
+    context "when user is not authenticated" do
+      before do
+        stub_connection current_user: nil
+      end
+
+      it "rejects the subscription" do
+        subscribe user_id: user.id
+
+        expect(subscription).to be_rejected
+      end
+    end
+  end
+end

package/templates/stacks/ruby-rails-8/spec/factories/users.rb

@@ -0,0 +1,27 @@
+# frozen_string_literal: true
+
+# DARE v3.0 — FactoryBot factories
+# Convention: no fixtures YAML; FactoryBot only
+
+FactoryBot.define do
+  factory :user do
+    sequence(:email) { |n| "user#{n}@example.com" }
+    name             { Faker::Name.name }
+    active           { true }
+
+    # Trait: admin user
+    trait :admin do
+      admin { true }
+    end
+
+    # Trait: inactive user
+    trait :inactive do
+      active { false }
+    end
+
+    # Trait: with all optional fields
+    trait :complete do
+      last_active_at { 1.day.ago }
+    end
+  end
+end

package/templates/stacks/ruby-rails-8/spec/handlers/users_handler_spec.rb

@@ -0,0 +1,88 @@
+# frozen_string_literal: true
+
+# DARE v3.0 — UsersHandler spec
+# Convention (ADR-06): request specs test HTTP contract
+require "rails_helper"
+
+RSpec.describe "Users API", type: :request do
+  let(:user)         { create(:user) }
+  let(:valid_params) { { user: { email: "bob@example.com", name: "Bob" } } }
+
+  describe "GET /api/users/:id" do
+    context "when user exists" do
+      it "returns 200 with user JSON" do
+        get "/api/users/#{user.id}"
+
+        expect(response).to have_http_status(:ok)
+        json = JSON.parse(response.body)
+        expect(json["email"]).to eq user.email
+      end
+    end
+
+    context "when user does not exist" do
+      it "returns 404 Problem Details" do
+        get "/api/users/99999"
+
+        expect(response).to have_http_status(:not_found)
+        json = JSON.parse(response.body)
+        expect(json["status"]).to eq 404
+        expect(json["title"]).to be_present
+        expect(response.content_type).to include("application/problem+json")
+      end
+    end
+  end
+
+  describe "POST /api/users" do
+    context "with valid params" do
+      it "returns 201 Created" do
+        post "/api/users", params: valid_params, as: :json
+
+        expect(response).to have_http_status(:created)
+        json = JSON.parse(response.body)
+        expect(json["email"]).to eq "bob@example.com"
+      end
+    end
+
+    context "with duplicate email" do
+      before { create(:user, email: "bob@example.com") }
+
+      it "returns 409 Conflict with Problem Details" do
+        post "/api/users", params: valid_params, as: :json
+
+        expect(response).to have_http_status(:conflict)
+        json = JSON.parse(response.body)
+        expect(json["status"]).to eq 409
+        expect(response.content_type).to include("application/problem+json")
+      end
+    end
+
+    context "with missing required params" do
+      it "returns 400 Bad Request" do
+        post "/api/users", params: { user: {} }, as: :json
+
+        expect(response).to have_http_status(:bad_request)
+      end
+    end
+  end
+
+  describe "PATCH /api/users/:id" do
+    it "returns 200 with updated user" do
+      patch "/api/users/#{user.id}",
+            params: { user: { name: "Updated Name" } },
+            as:     :json,
+            headers: { "Authorization" => "Bearer test-token" }
+
+      # Note: authentication stub needed — wire up in test support
+      expect(response).not_to have_http_status(:internal_server_error)
+    end
+  end
+
+  describe "DELETE /api/users/:id" do
+    it "returns 204 No Content" do
+      delete "/api/users/#{user.id}",
+             headers: { "Authorization" => "Bearer test-token" }
+
+      expect(response).not_to have_http_status(:internal_server_error)
+    end
+  end
+end

package/templates/stacks/ruby-rails-8/spec/rails_helper.rb

@@ -0,0 +1,31 @@
+# frozen_string_literal: true
+
+# DARE v3.0 — RSpec rails_helper
+
+ENV["RAILS_ENV"] ||= "test"
+require_relative "../config/environment"
+require "rspec/rails"
+
+# Require support files
+Dir[Rails.root.join("spec/support/**/*.rb")].each { |f| require f }
+
+# Prevent database truncation if the environment is production
+abort("The Rails environment is running in production mode!") if Rails.env.production?
+
+RSpec.configure do |config|
+  config.fixture_paths = ["#{::Rails.root}/spec/fixtures"]
+  config.use_transactional_fixtures = true
+  config.infer_spec_type_from_file_location!
+  config.filter_rails_from_backtrace!
+
+  # FactoryBot
+  config.include FactoryBot::Syntax::Methods
+
+  # Shoulda Matchers
+  Shoulda::Matchers.configure do |shoulda|
+    shoulda.integrate do |with|
+      with.test_framework :rspec
+      with.library        :rails
+    end
+  end
+end