rails-kompot 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: ce2101caab873f356ff63b3262ae0b1a7e88b616376acc10c5c9853be7dc8861
+  data.tar.gz: b03b947969c3eb99899c611485d3b4677716117db1ecda2c5edd35a7c8228001
+SHA512:
+  metadata.gz: 8ffa3135b12e83c99298c1f4822363f1712cfe6abf29ca5d47f8de5aea342bf2fc99ce9af750e48dae3d5b5bb3b7dfd52c44d85b0a6e0eec4720851b7ad0e0a9
+  data.tar.gz: 866b22ee5d2e925234a8ce4583de9605dab28ede63f436009563f9d942b698c7189470b74dfe8eafeb0c822f03b1b468ff2d80eb2da1a48d89d90ece666d07b5

data/CHANGELOG.md

@@ -0,0 +1,13 @@
+# Changelog
+
+All notable changes to this project will be documented in this file.
+
+The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.0.0/),
+and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
+
+## [0.1.0] - 2026-03-02
+
+### Added
+
+- Initial release
+- CLI wrapper around `rails new` with sensible defaults: PostgreSQL, API-only, minimal, no test framework

data/LICENSE.txt

@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) 2026 Anatolii Kryvishyn
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.

data/README.md

@@ -0,0 +1,98 @@
+# rails-kompot
+
+A CLI wrapper around `rails new` that bootstraps a production-ready API-only Rails application with testing, linting, and Claude Code skills pre-configured.
+
+## Installation
+
+```bash
+gem install rails-kompot
+```
+
+## Usage
+
+```bash
+rails-kompot new my_app
+```
+
+This creates a new Rails app configured for:
+
+- **PostgreSQL** — primary database
+- **API-only mode** — no views, assets, or browser middleware
+- **Minimal footprint** — only essential Rails components loaded
+
+## What you get
+
+### Gems
+
+| Gem | Purpose |
+|-----|---------|
+| `rspec-rails` | Test framework |
+| `factory_bot_rails` | Test factories |
+| `rubocop` + `rubocop-rails` + `rubocop-rspec` | Linting and style enforcement |
+| `test-prof` | Test profiling (FPROF, `let_it_be`, `before_all`) |
+| `simplecov` | Code coverage reporting |
+| `bullet` | N+1 query detection in development |
+
+### Configuration
+
+- **`.rubocop.yml`** — pre-configured with Rails and RSpec cops
+- **SimpleCov** — configured in `spec/spec_helper.rb` with an 80% minimum coverage threshold
+- **Bullet** — enabled in `config/environments/development.rb` with Rails logger output
+
+### Claude skills
+
+The generated app includes 8 custom Claude Code slash commands in `.claude/commands/`:
+
+| Skill | Description |
+|-------|-------------|
+| `/lint` | Run RuboCop on changed files and auto-correct fixable offenses |
+| `/review-pr` | Diff current branch against main; review for quality, N+1s, missing specs, and type consistency |
+| `/fix` | Diagnose and fix a failing test, RuboCop offense, or error message |
+| `/code-coverage` | Run RSpec, parse SimpleCov output, and suggest specs for under-covered files |
+| `/add-tests` | Generate RSpec unit specs for given source files using test-prof conventions |
+| `/commit` | Analyze changes and create a conventional commit message |
+| `/docs` | Generate or update `docs/` markdown for given `app/` source files |
+| `/deliver` | Run all quality gates in a loop until green, then commit |
+
+### `/docs` skill
+
+`/docs` mirrors your `app/` directory into `docs/` as structured markdown. For each source file you pass it:
+
+1. Reads the class/module and infers method input/output types from signatures, defaults, guard clauses, return expressions, and `db/schema.rb`
+2. Greps the codebase for callers to identify business flows
+3. Creates or updates `docs/<path>.md` — preserving any manually-added notes while refreshing auto-generated sections
+
+Example: `/docs app/models/user.rb app/services/payment_processor.rb`
+
+### `/deliver` workflow
+
+`/deliver` is a one-command quality gate loop:
+
+1. **Tests + FPROF** — runs `FPROF=1 bundle exec rspec`; fixes failures; refactors excessive DB record creation to use `let_it_be`/`before_all`
+2. **Coverage** — generates a fresh SimpleCov report and runs `/code-coverage` to add missing specs until the 80% threshold is met
+3. **Lint** — runs `/lint` to auto-correct and fix all RuboCop offenses
+4. **Code review** — runs `/review-pr` and fixes every blocker
+5. **Docs** — runs `/docs` on all changed `app/` files to create or update their `docs/` markdown
+6. **Final verification** — re-runs tests and RuboCop; returns to the relevant step if anything fails
+7. **Commit** — runs `/commit` to create a conventional commit
+
+You make code changes, then run `/deliver` — Claude handles the rest.
+
+## Requirements
+
+- Ruby >= 3.0
+- Rails (railties) >= 7.0
+
+## Development
+
+After checking out the repo, run `bin/setup` to install dependencies. You can also run `bin/console` for an interactive prompt.
+
+To install this gem onto your local machine, run `bundle exec rake install`. To release a new version, update the version number in `version.rb`, and then run `bundle exec rake release`, which will create a git tag for the version, push git commits and the created tag, and push the `.gem` file to [rubygems.org](https://rubygems.org).
+
+## Contributing
+
+Bug reports and pull requests are welcome on GitHub at https://github.com/kompoteria/rails-kompot. Please open an issue before submitting a pull request for significant changes.
+
+## License
+
+The gem is available as open source under the terms of the [MIT License](https://opensource.org/licenses/MIT).

data/Rakefile

@@ -0,0 +1,4 @@
+# frozen_string_literal: true
+
+require "bundler/gem_tasks"
+task default: %i[]

data/exe/rails-kompot

@@ -0,0 +1,91 @@
+#!/usr/bin/env ruby
+# frozen_string_literal: true
+
+require "fileutils"
+
+PRESET_FLAGS = %w[-d postgresql -T --api --minimal].freeze
+
+def usage
+  <<~USAGE
+    Usage: rails-kompot new <app_name_or_path> [extra rails options]
+
+    Creates a new Rails API application with preset flags:
+      #{PRESET_FLAGS.join(" ")}
+
+    Examples:
+      rails-kompot new my_app
+      rails-kompot new .
+      rails-kompot new my_app --skip-git
+  USAGE
+end
+
+command = ARGV[0]
+
+if command.nil? || command == "--help" || command == "-h"
+  puts usage
+  exit command.nil? ? 1 : 0
+end
+
+unless command == "new"
+  warn "Unknown command: #{command}"
+  warn usage
+  exit 1
+end
+
+app_name = ARGV[1]
+
+if app_name.nil?
+  warn "Error: missing app name or path\n\n"
+  warn usage
+  exit 1
+end
+
+extra_args = ARGV[2..]
+
+cmd = ["rails", "new", app_name, *PRESET_FLAGS, *extra_args]
+puts "Running: #{cmd.join(" ")}"
+system(*cmd) || abort("rails new failed")
+
+app_dir = app_name == "." ? Dir.pwd : File.expand_path(app_name)
+templates_dir = File.join(__dir__, "..", "templates")
+
+Dir.glob("#{templates_dir}/**/*", File::FNM_DOTMATCH).each do |src|
+  next if File.directory?(src)
+  relative = src.delete_prefix("#{templates_dir}/")
+  dest = File.join(app_dir, relative)
+  FileUtils.mkdir_p(File.dirname(dest))
+  FileUtils.cp(src, dest)
+end
+
+gemfile_path = File.join(app_dir, "Gemfile")
+File.open(gemfile_path, "a") do |f|
+  f.puts 'gem "factory_bot"'
+  f.puts
+  f.puts 'group :development do'
+  f.puts '  gem "rubocop"'
+  f.puts '  gem "rubocop-rails"'
+  f.puts '  gem "rubocop-rspec"'
+  f.puts '  gem "bullet"'
+  f.puts 'end'
+  f.puts
+  f.puts 'group :development, :test do'
+  f.puts '  gem "rspec-rails"'
+  f.puts '  gem "test-prof"'
+  f.puts '  gem "simplecov"'
+  f.puts 'end'
+end
+
+puts "Running: bundle install"
+system("bundle", "install", chdir: app_dir) || abort("bundle install failed")
+
+puts "Running: rails generate rspec:install"
+system("bundle", "exec", "rails", "generate", "rspec:install", chdir: app_dir) || abort("rails generate rspec:install failed")
+
+spec_helper_path = File.join(app_dir, "spec", "spec_helper.rb")
+if File.exist?(spec_helper_path)
+  original = File.read(spec_helper_path)
+  File.write(spec_helper_path, %(require "simplecov"\nSimpleCov.start "rails"\n\n) + original)
+end
+
+puts "Running: bundle exec rails g bullet:install"
+system("bundle", "exec", "rails", "g", "bullet:install", chdir: app_dir) || abort("rails g bullet:install failed")

data/lib/rails/kompot/version.rb

@@ -0,0 +1,7 @@
+# frozen_string_literal: true
+
+module Rails
+  module Kompot
+    VERSION = "0.1.0"
+  end
+end

data/lib/rails/kompot.rb

@@ -0,0 +1,10 @@
+# frozen_string_literal: true
+
+require_relative "kompot/version"
+
+module Rails
+  module Kompot
+    class Error < StandardError; end
+    # Your code goes here...
+  end
+end

data/sig/rails/kompot.rbs

@@ -0,0 +1,6 @@
+module Rails
+  module Kompot
+    VERSION: String
+    # See the writing guide of rbs: https://github.com/ruby/rbs#guides
+  end
+end

data/templates/.claude/commands/add-tests.md

@@ -0,0 +1,22 @@
+Generate unit specs for the given source files.
+
+## Steps
+
+1. Read each source file specified in `$ARGUMENTS` to understand its public API, dependencies, and DB interactions.
+
+2. Look at existing specs in the project to learn conventions (describe/context/it structure, factory patterns, test-prof usage).
+
+3. Write spec files following these rules:
+   - **Unit tests** — test each method/behavior in isolation; mock external dependencies
+   - Use `let_it_be` / `let_it_be_refined` instead of `let` / `let!` for DB-backed test data
+   - Use `AnyFixture` for shared reference data (roles, statuses, config records) that doesn't change across examples
+   - Spec file placement mirrors source: `app/models/user.rb` → `spec/models/user_spec.rb`
+
+4. Run each new spec with `FPROF=1` to check DB record creation:
+   ```bash
+   FPROF=1 bundle exec rspec <spec_file>
+   ```
+
+5. Review the FPROF output. If unnecessary DB records are created per-example, refactor test data to use `let_it_be` or `AnyFixture`.
+
+6. Fix any failures and re-run until all specs are green.

data/templates/.claude/commands/code-coverage.md

@@ -0,0 +1,26 @@
+Analyze existing SimpleCov coverage results and write missing specs to improve coverage.
+
+## Steps
+
+1. Read the existing coverage report at `coverage/index.html`. Do not run the test suite — assume the user has already run it and the report is current.
+
+2. Parse the HTML report for:
+   - **Overall coverage percentage**
+   - **Files below 80% coverage** — list each file with its coverage percentage
+   - **Uncovered lines** — for each low-coverage file, identify which methods or branches are not covered
+
+3. For each low-coverage file, read the source file to understand what needs to be tested.
+
+4. Write the missing specs:
+   - Create or extend the appropriate spec file (e.g. `spec/models/user_spec.rb`)
+   - Cover the uncovered methods, branches, and edge cases identified in step 2
+   - Follow existing spec conventions in the project (describe/context/it blocks, factory usage, etc.)
+   - **Unit tests** — test each method/behavior in isolation; mock external dependencies
+   - Use `let_it_be` / `let_it_be_refined` instead of `let` / `let!` for DB-backed test data
+   - Use `AnyFixture` for shared reference data (roles, statuses, config records) that doesn't change across examples
+
+5. Run each new or modified spec with `FPROF=1` to check DB record creation:
+   ```bash
+   FPROF=1 bundle exec rspec <spec_file>
+   ```
+   Review the FPROF output — if unnecessary DB records are created per-example, refactor test data to use `let_it_be` or `AnyFixture`. Fix any failures before moving on to the next file.

data/templates/.claude/commands/commit.md

@@ -0,0 +1,29 @@
+Analyze the staged and unstaged changes and create a commit with a minimal, accurate message.
+
+## Steps
+
+1. Inspect what has changed:
+
+   ```bash
+   git status
+   git diff
+   git diff --cached
+   ```
+
+2. Analyze the changes and derive the commit message:
+   - Identify the single most important thing the changes accomplish.
+   - Use the conventional format: `<type>: <short description>` (e.g. `feat:`, `fix:`, `refactor:`, `test:`, `chore:`).
+   - Keep the subject line under 72 characters.
+   - Use the imperative mood ("add", "fix", "remove" — not "added", "fixes").
+   - Do not pad with filler words or repeat the diff verbatim.
+   - If the changes span genuinely unrelated concerns, split into multiple commits.
+
+3. Stage all relevant changes and commit:
+
+   ```bash
+   git add -p   # or git add <specific files>
+   git commit -m "<type>: <short description>"
+   ```
+
+   Do not include `--no-verify` or any flag that bypasses hooks.
+   Do not include co-authors in a commit.

data/templates/.claude/commands/deliver.md

@@ -0,0 +1,23 @@
+Run all quality gates in sequence, fixing issues as you go, until everything is green.
+
+## Steps
+
+1. **Tests + FPROF** — Run `FPROF=1 bundle exec rspec`. If any specs fail, use `/fix` to diagnose and resolve each failure. Review FPROF output — if any example group creates excessive DB records, refactor to use `let_it_be` / `before_all`. Re-run until green.
+
+2. **Code coverage** — Run `bundle exec rspec` to generate a fresh SimpleCov report, then run the `/code-coverage` skill to identify under-covered files and write missing specs. Re-run until all files meet the 80% threshold.
+
+3. **Lint** — Run the `/lint` skill to auto-correct and fix all RuboCop offenses.
+
+4. **Code review** — Run the `/review-pr` skill to diff against main, review for quality issues, and fix all blockers.
+
+5. **Documentation** — Identify changed `.rb` files under `app/` with:
+
+   ```bash
+   git diff --name-only main | grep '^app/.*\.rb$'
+   ```
+
+   Run the `/docs` skill on those files to create or update their documentation in `docs/`.
+
+6. **Final verification** — Re-run `FPROF=1 bundle exec rspec` and `bundle exec rubocop`. If anything fails, return to the relevant step. Repeat until both are clean.
+
+7. **Commit** — If there are uncommitted changes, run the `/commit` skill.

data/templates/.claude/commands/docs.md

@@ -0,0 +1,122 @@
+Generate or update markdown documentation for one or more `app/` source files.
+
+## Usage
+
+```
+/docs app/models/user.rb app/services/payment_processor.rb
+```
+
+`$ARGUMENTS` — one or more file paths under `app/` (space-separated).
+
+## Steps
+
+For each file path in `$ARGUMENTS`:
+
+1. **Determine the mirror path** — replace the leading `app/` with `docs/` and the `.rb` extension with `.md`.
+   - Example: `app/models/user.rb` → `docs/models/user.md`
+
+2. **Read the source file** to understand the class/module: its purpose, public interface, constants, callbacks, validations, associations, and any inline comments.
+
+3. **Infer input/output types** for each method using:
+   - Method signatures and parameter names
+   - Type annotations or Sorbet/RBS signatures if present
+   - Default values (e.g. `limit: 10` implies Integer)
+   - Guard clauses and conditional branches (e.g. `return if user.nil?` implies nullable)
+   - Return expressions and their literal types
+   - Database schema for model attributes — read `db/schema.rb` to find column types
+   - Usage patterns — grep the codebase for calls to the method and observe argument types passed
+
+4. **Identify business flows** — grep the codebase for references to the class/module name to find its callers and the contexts in which it is used.
+
+5. **Check whether the docs file already exists**:
+   - If it **exists**: read it, then update it — preserve any manually-added notes or sections not generated by this skill, but refresh auto-generated sections (Purpose, Business flows, Methods) from the current source.
+   - If it **does not exist**: create the parent directories if needed and write the file from scratch.
+
+6. **Write the docs file** using the structure below.
+
+7. **Verify** that the docs file exists and is non-empty after writing.
+
+## Doc file structure
+
+```markdown
+# ClassName
+
+## Purpose
+One-paragraph description of what this class/module does and why it exists.
+
+## Business flows
+- Flow or use case 1 — brief description of how this class is involved
+- Flow or use case 2 — ...
+(List only flows discovered from grepping callers; omit if no callers found.)
+
+## Methods
+
+### `.class_method(arg1, arg2)`
+- **Input**: `arg1` — Type, description; `arg2` — Type, description
+- **Output**: Type — description
+- What the method does.
+
+### `#instance_method(arg1)`
+- **Input**: `arg1` — Type, description
+- **Output**: Type — description
+- What the method does.
+```
+
+**Conventions:**
+- Prefix class methods with `.` and instance methods with `#`.
+- Document only public methods. Skip private/protected methods unless they are the primary interface.
+- For model attributes (columns), list them in a `## Attributes` section with column type and description instead of under Methods.
+- If the class has no public methods beyond ActiveRecord defaults, omit the Methods section.
+
+## Example
+
+Below is a filled-in example for `app/services/payment_processor.rb` → `docs/services/payment_processor.md`:
+
+```markdown
+# PaymentProcessor
+
+## Purpose
+Handles charge creation and refund processing against the Stripe API. Wraps the raw Stripe client so
+controllers and background jobs never interact with the gateway directly. All monetary amounts are
+expected in cents (Integer) and all currency codes follow ISO 4217 (e.g. `"usd"`).
+
+## Business flows
+- **Checkout** (`app/controllers/api/v1/orders_controller.rb`) — calls `.charge` after an order is
+  confirmed to capture payment before fulfillment begins.
+- **Subscription renewal** (`app/jobs/renewal_job.rb`) — calls `.charge` on a recurring schedule;
+  on failure, calls `#refund` for any partial capture before retrying.
+- **Support refunds** (`app/services/support_action_service.rb`) — calls `#refund` when a support
+  agent issues a full or partial refund from the admin panel.
+
+## Attributes
+> `PaymentProcessor` is a plain service object, not an ActiveRecord model — it has no database
+> columns. See `app/models/payment.rb` for the persisted payment record.
+
+## Methods
+
+### `.charge(user:, amount_cents:, currency: "usd")`
+- **Input**: `user:` — User, the account being charged (used to look up the stored Stripe customer
+  ID); `amount_cents:` — Integer, amount in cents (must be > 0); `currency:` — String, ISO 4217
+  currency code (default `"usd"`)
+- **Output**: `Payment` — a persisted `Payment` record with `status: "succeeded"` on success, or
+  raises `PaymentProcessor::ChargeError` on gateway failure
+- Creates a Stripe `PaymentIntent`, confirms it immediately, then persists a `Payment` record linked
+  to the user. Raises `ChargeError` (wrapping the Stripe exception) if the charge is declined or
+  the gateway is unreachable.
+
+### `.supported_currencies`
+- **Input**: none
+- **Output**: Array\<String\> — list of ISO 4217 currency codes accepted by the current Stripe
+  account (e.g. `["usd", "eur", "gbp"]`)
+- Fetches the list from Stripe on first call and memoizes it for the lifetime of the process.
+
+### `#refund(payment:, amount_cents: nil)`
+- **Input**: `payment:` — Payment, the record to refund (must have `status: "succeeded"`);
+  `amount_cents:` — Integer | nil, partial refund amount in cents; if `nil`, refunds the full
+  original charge
+- **Output**: `Payment` — the same record, updated with `status: "refunded"` (full) or
+  `status: "partially_refunded"`
+- Issues a Stripe refund for the given `PaymentIntent`. Updates the `Payment` record in a
+  transaction so the record and Stripe stay in sync. Raises `PaymentProcessor::RefundError` if the
+  payment is already fully refunded or if the gateway call fails.
+```

data/templates/.claude/commands/fix.md

@@ -0,0 +1,23 @@
+Diagnose and fix a failing test, RuboCop offense, or error. Pass a description of the problem as the argument.
+
+Usage: `/fix <description of the problem>`
+
+Examples:
+- `/fix bundle exec rspec spec/models/user_spec.rb:42 is failing`
+- `/fix rubocop offense: Metrics/MethodLength in app/services/user_service.rb`
+- `/fix NoMethodError: undefined method 'foo' for nil:NilClass in app/controllers/users_controller.rb`
+
+## Steps
+
+1. Read the relevant file(s) identified in the problem description.
+
+2. Diagnose the root cause — do not guess; trace the actual error or failing assertion.
+
+3. Apply the minimal fix needed to resolve the issue.
+
+4. Verify the fix by re-running the relevant command:
+   - **Failing test**: `bundle exec rspec <path/to/spec_file>` (use the specific file and line if available)
+   - **RuboCop offense**: `bundle exec rubocop <path/to/file>`
+   - **Runtime error**: re-run the command or request that raised the error
+
+5. If the fix passes verification, report what was changed and why. If it still fails, diagnose further before trying another approach.

data/templates/.claude/commands/lint.md

@@ -0,0 +1,28 @@
+Run RuboCop on changed files or the whole project, auto-correct fixable offenses, then fix any remaining offenses by editing the code directly.
+
+## Steps
+
+1. Get the list of changed Ruby files:
+   ```bash
+   git diff --name-only HEAD | grep '\.rb$'
+   ```
+   If there are changed files, run RuboCop on those files. If there are no changed files (e.g. clean working tree), run RuboCop on the whole project.
+
+2. Run RuboCop:
+   - On changed files: `bundle exec rubocop <file1> <file2> ...`
+   - On whole project: `bundle exec rubocop`
+
+3. If any offenses are found, attempt auto-correction:
+   ```bash
+   bundle exec rubocop -A <files or blank for all>
+   ```
+
+4. Re-run RuboCop to see what remains after auto-correction.
+
+5. For each remaining offense that RuboCop could not auto-correct:
+   - Read the offending file
+   - Understand the root cause of the offense (don't just silence the cop)
+   - Edit the code to fix it properly
+   - Repeat for all remaining offenses
+
+6. Re-run RuboCop to confirm all offenses are resolved and no new ones were introduced.

data/templates/.claude/commands/review-pr.md

@@ -0,0 +1,35 @@
+Review the current branch against main and provide actionable feedback.
+
+## Steps
+
+1. Get the diff of the current branch against main:
+
+   ```bash
+   git diff main...HEAD
+   ```
+
+2. Also get the list of changed files:
+
+   ```bash
+   git diff --name-only main...HEAD
+   ```
+
+3. Review the changes for:
+   - **Code quality** — clarity, duplication, naming, Rails conventions
+   - **N+1 queries** — look for loops with ActiveRecord calls that lack `.includes`/`.preload`/`.eager_load`; Bullet will surface these at runtime but flag obvious ones in review
+   - **Missing specs** — for each new model, controller, service, or public method, check that a corresponding spec exists or is added in this PR
+   - **RuboCop compliance** — flag style issues not caught by auto-correct (complex logic, missing frozen_string_literal, etc.)
+   - **Documentation type consistency** — For each changed file under `app/`, check whether a corresponding `docs/` file exists (mirror path: replace `app/` prefix with `docs/` and `.rb` with `.md`). If it does, read the documented input/output types for each method. Then inspect callers of those methods in the diff and verify that arguments passed are consistent with the documented types. Flag type mismatches as **blockers**.
+
+4. End with a summary: overall assessment, blockers vs. suggestions, and any positive highlights.
+
+5. Fix every **blocker** identified in the summary:
+   - Edit the relevant source files directly to resolve each blocking issue.
+   - After applying fixes, re-run the test suite and RuboCop to verify no regressions were introduced:
+
+     ```bash
+     bundle exec rspec
+     bundle exec rubocop
+     ```
+
+   - If new failures appear, fix them before finishing.

data/templates/.rubocop.yml

@@ -0,0 +1,7 @@
+require:
+  - rubocop-rails
+  - rubocop-rspec
+
+AllCops:
+  NewCops: enable
+  TargetRubyVersion: 3.2

data/templates/CLAUDE.md

@@ -0,0 +1,73 @@
+# Project
+
+This is a Rails API-only application generated with [rails-kompot](https://github.com/kompoteria/rails-kompot).
+
+## Stack
+
+- **Rails** — API-only mode (`config.api_only = true`)
+- **PostgreSQL** — primary database
+- **Minimal** — only essential gems included (`--minimal` flag)
+- **RSpec** — test framework (rspec-rails), with SimpleCov for coverage and test-prof for profiling
+- **RuboCop** — linting and style enforcement (rubocop-rails, rubocop-rspec)
+- **Bullet** — N+1 query detection (enabled in development)
+
+## Key conventions
+
+- Routes live in `config/routes.rb`; prefer namespaced API versioning (e.g. `namespace :api { namespace :v1 { ... } }`)
+- Controllers inherit from `ActionController::API`
+- Use `render json:` for responses; avoid views and assets
+- Keep business logic out of controllers — use plain Ruby objects or service objects in `app/`
+- Database credentials are in `config/database.yml`; use environment variables for secrets
+
+## Setup
+
+```bash
+bin/rails db:create db:migrate
+bin/rails server
+```
+
+## Testing
+
+```bash
+# Run the full test suite
+bundle exec rspec
+
+# Run a specific file
+bundle exec rspec spec/models/user_spec.rb
+
+# Run a specific example
+bundle exec rspec spec/models/user_spec.rb:42
+
+# Run with coverage report (SimpleCov outputs to coverage/)
+bundle exec rspec
+```
+
+## Linting
+
+```bash
+# Check for offenses
+bundle exec rubocop
+
+# Auto-correct fixable offenses
+bundle exec rubocop -A
+
+# Check a specific file
+bundle exec rubocop app/models/user.rb
+```
+
+## Available Claude skills
+
+This project includes custom Claude Code slash commands in `.claude/commands/`:
+
+- `/lint` — Run RuboCop on changed files (or whole project) and auto-correct fixable offenses
+- `/review-pr` — Diff current branch against main and review for code quality, N+1s, missing specs, and style
+- `/fix` — Diagnose and fix a failing test, RuboCop offense, or error message
+- `/code-coverage` — Run RSpec, analyze SimpleCov results, and suggest specs to add
+- `/add-tests` — Generate unit specs for given source files using test-prof conventions
+- `/commit` — Analyze staged and unstaged changes and create a commit with a minimal, accurate conventional message
+- `/docs` — Generate or update markdown documentation in `docs/` for given `app/` source files, mirroring their path structure
+- `/deliver` — Run all quality gates (tests+FPROF, coverage, RuboCop, code review) in a loop, fixing issues until everything is green, then commit
+
+## Self-improvement
+
+When a skill fails, produces incorrect output, or the user requests adjustments to Claude's behavior (e.g. "always do X", "stop doing Y", "add Z to reviews"), ask the user whether they'd like to update the relevant skill file in `.claude/commands/` or `CLAUDE.md` to capture the adjustment. This prevents repeating the same mistakes across sessions.

metadata

@@ -0,0 +1,86 @@
+--- !ruby/object:Gem::Specification
+name: rails-kompot
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+platform: ruby
+authors:
+- Anatolii Kryvishyn
+bindir: exe
+cert_chain: []
+date: 1980-01-02 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: railties
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '7.0'
+    - - "<"
+      - !ruby/object:Gem::Version
+        version: '9'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '7.0'
+    - - "<"
+      - !ruby/object:Gem::Version
+        version: '9'
+description: A CLI wrapper around `rails new` that applies preset flags (-d postgresql
+  -T --api --minimal).
+email:
+- 9845250+anatoliikryvishyn@users.noreply.github.com
+executables:
+- rails-kompot
+extensions: []
+extra_rdoc_files: []
+files:
+- CHANGELOG.md
+- LICENSE.txt
+- README.md
+- Rakefile
+- exe/rails-kompot
+- lib/rails/kompot.rb
+- lib/rails/kompot/version.rb
+- sig/rails/kompot.rbs
+- templates/.claude/commands/add-tests.md
+- templates/.claude/commands/code-coverage.md
+- templates/.claude/commands/commit.md
+- templates/.claude/commands/deliver.md
+- templates/.claude/commands/docs.md
+- templates/.claude/commands/fix.md
+- templates/.claude/commands/lint.md
+- templates/.claude/commands/review-pr.md
+- templates/.rubocop.yml
+- templates/CLAUDE.md
+homepage: https://github.com/kompoteria/rails-kompot
+licenses:
+- MIT
+metadata:
+  homepage_uri: https://github.com/kompoteria/rails-kompot
+  source_code_uri: https://github.com/kompoteria/rails-kompot
+  changelog_uri: https://github.com/kompoteria/rails-kompot/blob/main/CHANGELOG.md
+  bug_tracker_uri: https://github.com/kompoteria/rails-kompot/issues
+  rubygems_mfa_required: 'true'
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: 3.0.0
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 4.0.3
+specification_version: 4
+summary: 'Rails new with sensible defaults: PostgreSQL, API-only, minimal, no test
+  framework.'
+test_files: []