source_monitor 0.2.0 → 0.3.0

data/.claude/skills/action-cable-patterns/SKILL.md

@@ -0,0 +1,296 @@
+---
+name: action-cable-patterns
+description: Implements real-time features with Action Cable and WebSockets. Use when adding live updates, chat features, notifications, real-time dashboards, or when user mentions Action Cable, WebSockets, channels, or real-time.
+allowed-tools: Read, Write, Edit, Bash, Glob, Grep
+---
+
+# Action Cable Patterns for Rails 8
+
+## Overview
+
+Action Cable integrates WebSockets with Rails:
+- Real-time updates without polling
+- Server-to-client push notifications
+- Chat and messaging features
+- Live dashboards and feeds
+
+## Quick Start
+
+```yaml
+# config/cable.yml
+development:
+  adapter: async
+
+test:
+  adapter: test
+
+production:
+  adapter: solid_cable  # Rails 8 default
+```
+
+## Connection Authentication
+
+```ruby
+# app/channels/application_cable/connection.rb
+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
+      if session_token = cookies.signed[:session_token]
+        if session = Session.find_by(token: session_token)
+          session.user
+        else
+          reject_unauthorized_connection
+        end
+      else
+        reject_unauthorized_connection
+      end
+    end
+  end
+end
+```
+
+## Channel Patterns
+
+### Pattern 1: Notifications Channel
+
+```ruby
+# app/channels/notifications_channel.rb
+class NotificationsChannel < ApplicationCable::Channel
+  def subscribed
+    stream_for current_user
+  end
+
+  def self.notify(user, notification)
+    broadcast_to(user, {
+      type: "notification",
+      id: notification.id,
+      title: notification.title,
+      body: notification.body
+    })
+  end
+end
+```
+
+### Pattern 2: Resource Updates Channel
+
+```ruby
+# app/channels/events_channel.rb
+class EventsChannel < ApplicationCable::Channel
+  def subscribed
+    @event = Event.find(params[:event_id])
+
+    if authorized?
+      stream_for @event
+    else
+      reject
+    end
+  end
+
+  def self.broadcast_update(event)
+    broadcast_to(event, {
+      type: "update",
+      html: ApplicationController.renderer.render(
+        partial: "events/event", locals: { event: event }
+      )
+    })
+  end
+
+  private
+
+  def authorized?
+    EventPolicy.new(current_user, @event).show?
+  end
+end
+```
+
+### Pattern 3: Integration with Turbo Streams
+
+```ruby
+# app/models/comment.rb
+class Comment < ApplicationRecord
+  after_create_commit -> {
+    broadcast_append_to(
+      [event, "comments"],
+      target: "comments",
+      partial: "comments/comment"
+    )
+  }
+
+  after_destroy_commit -> {
+    broadcast_remove_to([event, "comments"])
+  }
+end
+```
+
+```erb
+<%# app/views/events/show.html.erb %>
+<%= turbo_stream_from @event, "comments" %>
+
+<div id="comments">
+  <%= render @event.comments %>
+</div>
+```
+
+## Broadcasting from Services
+
+```ruby
+module Events
+  class UpdateService
+    def call(event, params)
+      event.update!(params)
+      EventsChannel.broadcast_update(event)
+      DashboardChannel.broadcast_stats(event.account)
+      success(event)
+    end
+  end
+end
+```
+
+## Testing Channels
+
+### Channel Test (Minitest)
+
+```ruby
+# test/channels/notifications_channel_test.rb
+require "test_helper"
+
+class NotificationsChannelTest < ActionCable::Channel::TestCase
+  setup do
+    @user = users(:one)
+    stub_connection(current_user: @user)
+  end
+
+  test "subscribes successfully" do
+    subscribe
+    assert subscription.confirmed?
+  end
+
+  test "streams for the current user" do
+    subscribe
+    assert_has_stream_for @user
+  end
+
+  test "broadcasts notification to user" do
+    subscribe
+    notification = notifications(:one)
+
+    assert_broadcast_on(
+      NotificationsChannel.broadcasting_for(@user),
+      hash_including(type: "notification")
+    ) do
+      NotificationsChannel.notify(@user, notification)
+    end
+  end
+end
+```
+
+### Channel with Authorization Test
+
+```ruby
+# test/channels/events_channel_test.rb
+require "test_helper"
+
+class EventsChannelTest < ActionCable::Channel::TestCase
+  setup do
+    @user = users(:one)
+    @event = events(:one) # belongs to @user's account
+    @other_event = events(:other_account)
+    stub_connection(current_user: @user)
+  end
+
+  test "subscribes to authorized event" do
+    subscribe(event_id: @event.id)
+    assert subscription.confirmed?
+    assert_has_stream_for @event
+  end
+
+  test "rejects unauthorized event" do
+    subscribe(event_id: @other_event.id)
+    assert subscription.rejected?
+  end
+end
+```
+
+### Connection Test
+
+```ruby
+# test/channels/connection_test.rb
+require "test_helper"
+
+class ApplicationCable::ConnectionTest < ActionCable::Connection::TestCase
+  test "connects with valid session token" do
+    user = users(:one)
+    session = user.sessions.create!
+
+    connect cookies: { session_token: session.token }
+
+    assert_equal user, connection.current_user
+  end
+
+  test "rejects without session token" do
+    assert_reject_connection do
+      connect
+    end
+  end
+end
+```
+
+## Stimulus Controller for Channels
+
+```javascript
+// app/javascript/controllers/chat_controller.js
+import { Controller } from "@hotwired/stimulus"
+import consumer from "../channels/consumer"
+
+export default class extends Controller {
+  static targets = ["messages", "input"]
+  static values = { roomId: Number }
+
+  connect() {
+    this.channel = consumer.subscriptions.create(
+      { channel: "ChatChannel", room_id: this.roomIdValue },
+      {
+        received: this.received.bind(this),
+      }
+    )
+  }
+
+  disconnect() {
+    this.channel?.unsubscribe()
+  }
+
+  received(data) {
+    if (data.type === "message") {
+      this.messagesTarget.insertAdjacentHTML("beforeend", data.html)
+      this.messagesTarget.scrollTop = this.messagesTarget.scrollHeight
+    }
+  }
+
+  send(event) {
+    event.preventDefault()
+    const body = this.inputTarget.value.trim()
+    if (body) {
+      this.channel.perform("speak", { body })
+      this.inputTarget.value = ""
+    }
+  }
+}
+```
+
+## Checklist
+
+- [ ] Connection authentication configured
+- [ ] Channel authorization implemented
+- [ ] Channel tests written
+- [ ] Broadcasting from services/models
+- [ ] Client-side subscription set up
+- [ ] Turbo Stream integration (if applicable)
+- [ ] All tests GREEN

data/.claude/skills/action-mailer-patterns/SKILL.md

@@ -0,0 +1,295 @@
+---
+name: action-mailer-patterns
+description: Implements transactional emails with Action Mailer and TDD. Use when creating email templates, notification emails, password resets, email previews, or when user mentions mailer, email, notifications, or transactional emails.
+allowed-tools: Read, Write, Edit, Bash, Glob, Grep
+---
+
+# Action Mailer Patterns for Rails 8
+
+## Overview
+
+Action Mailer handles transactional emails:
+- HTML and text email templates
+- Layouts for consistent styling
+- Previews for development
+- Background delivery via Active Job (Solid Queue)
+- Internationalized emails
+
+## Quick Start
+
+```bash
+bin/rails generate mailer User welcome password_reset
+```
+
+## Configuration
+
+```ruby
+# config/environments/development.rb
+config.action_mailer.delivery_method = :letter_opener
+config.action_mailer.default_url_options = { host: "localhost", port: 3000 }
+
+# config/environments/production.rb
+config.action_mailer.delivery_method = :smtp
+config.action_mailer.default_url_options = { host: "example.com" }
+```
+
+### Application Mailer
+
+```ruby
+# app/mailers/application_mailer.rb
+class ApplicationMailer < ActionMailer::Base
+  default from: "noreply@example.com"
+  layout "mailer"
+
+  helper_method :app_name
+
+  private
+
+  def app_name
+    Rails.application.class.module_parent_name
+  end
+end
+```
+
+## TDD Workflow
+
+```
+Mailer Progress:
+- [ ] Step 1: Write mailer test (RED)
+- [ ] Step 2: Run test (fails)
+- [ ] Step 3: Create mailer method
+- [ ] Step 4: Create email templates
+- [ ] Step 5: Run test (GREEN)
+- [ ] Step 6: Create preview
+```
+
+## Testing Mailers (Minitest)
+
+### Mailer Test
+
+```ruby
+# test/mailers/user_mailer_test.rb
+require "test_helper"
+
+class UserMailerTest < ActionMailer::TestCase
+  setup do
+    @user = users(:one)
+  end
+
+  test "welcome email renders headers" do
+    mail = UserMailer.welcome(@user)
+
+    assert_equal I18n.t("user_mailer.welcome.subject"), mail.subject
+    assert_equal [@user.email_address], mail.to
+    assert_equal ["noreply@example.com"], mail.from
+  end
+
+  test "welcome email renders HTML body" do
+    mail = UserMailer.welcome(@user)
+
+    assert_includes mail.html_part.body.to_s, @user.name
+    assert_includes mail.html_part.body.to_s, "Welcome"
+  end
+
+  test "welcome email renders text body" do
+    mail = UserMailer.welcome(@user)
+
+    assert_includes mail.text_part.body.to_s, @user.name
+  end
+
+  test "welcome email includes login link" do
+    mail = UserMailer.welcome(@user)
+
+    assert_includes mail.html_part.body.to_s, new_session_url
+  end
+
+  test "password_reset email includes token" do
+    token = "reset-token-123"
+    mail = UserMailer.password_reset(@user, token)
+
+    assert_equal [@user.email_address], mail.to
+    assert_includes mail.html_part.body.to_s, token
+  end
+end
+```
+
+### Testing Delivery
+
+```ruby
+# test/integration/registration_test.rb
+require "test_helper"
+
+class RegistrationTest < ActionDispatch::IntegrationTest
+  test "registration sends welcome email" do
+    assert_enqueued_email_with UserMailer, :welcome do
+      post registrations_path, params: {
+        registration: { email: "new@example.com", name: "Test", password: "password123" }
+      }
+    end
+  end
+end
+```
+
+### Testing with perform_enqueued_jobs
+
+```ruby
+# test/integration/notification_test.rb
+require "test_helper"
+
+class NotificationTest < ActionDispatch::IntegrationTest
+  test "sends notification email" do
+    assert_emails 1 do
+      perform_enqueued_jobs do
+        NotificationMailer.daily_digest(users(:one)).deliver_later
+      end
+    end
+  end
+end
+```
+
+## Mailer Implementation
+
+### Basic Mailer
+
+```ruby
+# app/mailers/user_mailer.rb
+class UserMailer < ApplicationMailer
+  def welcome(user)
+    @user = user
+    @login_url = new_session_url
+
+    mail(to: @user.email_address, subject: t(".subject"))
+  end
+
+  def password_reset(user, token)
+    @user = user
+    @token = token
+    @reset_url = edit_password_url(token: token)
+    @expires_in = "24 hours"
+
+    mail(to: @user.email_address, subject: t(".subject"))
+  end
+end
+```
+
+### Mailer with Attachments
+
+```ruby
+class ReportMailer < ApplicationMailer
+  def monthly_report(user, report)
+    @user = user
+    @report = report
+
+    attachments["report-#{Date.current}.pdf"] = report.to_pdf
+
+    mail(to: @user.email_address, subject: t(".subject"))
+  end
+end
+```
+
+### Bundled Notification Pattern
+
+Send one email with multiple notifications instead of many emails:
+
+```ruby
+class NotificationMailer < ApplicationMailer
+  def daily_digest(user)
+    @user = user
+    @notifications = user.notifications.unread.today
+
+    return if @notifications.empty?
+
+    mail(to: @user.email_address, subject: t(".subject", count: @notifications.count))
+  end
+end
+```
+
+## Email Templates
+
+```erb
+<%# app/views/user_mailer/welcome.html.erb %>
+<h1><%= t(".greeting", name: @user.name) %></h1>
+<p><%= t(".intro") %></p>
+<p><%= link_to t(".login_button"), @login_url, class: "button" %></p>
+```
+
+```erb
+<%# app/views/user_mailer/welcome.text.erb %>
+<%= t(".greeting", name: @user.name) %>
+
+<%= t(".intro") %>
+
+<%= t(".login_prompt") %>: <%= @login_url %>
+```
+
+## Delivery Methods
+
+```ruby
+# Background delivery (preferred)
+UserMailer.welcome(user).deliver_later
+
+# With delay
+UserMailer.welcome(user).deliver_later(wait: 5.minutes)
+
+# Immediate (avoid in production)
+UserMailer.welcome(user).deliver_now
+```
+
+## Previews
+
+```ruby
+# test/mailers/previews/user_mailer_preview.rb
+class UserMailerPreview < ActionMailer::Preview
+  def welcome
+    user = User.first
+    UserMailer.welcome(user)
+  end
+
+  def password_reset
+    user = User.first
+    UserMailer.password_reset(user, "preview-token-123")
+  end
+end
+```
+
+Access at: `http://localhost:3000/rails/mailers`
+
+## I18n for Emails
+
+```yaml
+# config/locales/mailers/en.yml
+en:
+  user_mailer:
+    welcome:
+      subject: "Welcome to Our App!"
+      greeting: "Hello %{name}!"
+      intro: "Thanks for signing up."
+      login_button: "Log In Now"
+      login_prompt: "Log in here"
+    password_reset:
+      subject: "Reset Your Password"
+```
+
+### Localized Delivery
+
+```ruby
+class UserMailer < ApplicationMailer
+  def welcome(user)
+    @user = user
+    I18n.with_locale(user.locale || I18n.default_locale) do
+      mail(to: @user.email_address, subject: t(".subject"))
+    end
+  end
+end
+```
+
+## Checklist
+
+- [ ] Mailer test written first (RED)
+- [ ] Mailer method created
+- [ ] HTML template created
+- [ ] Text template created
+- [ ] Uses I18n for all text
+- [ ] Preview created
+- [ ] Uses `deliver_later` (not `deliver_now`)
+- [ ] All tests GREEN