kodelyth-ecc 1.5.5 → 1.5.7

package/rules/common/agents.md

@@ -1,50 +1,146 @@
 # Agent Orchestration
 
-## Available Agents
-
-Located in `~/.claude/agents/`:
-
-| Agent | Purpose | When to Use |
-|-------|---------|-------------|
-| planner | Implementation planning | Complex features, refactoring |
-| architect | System design | Architectural decisions |
-| tdd-guide | Test-driven development | New features, bug fixes |
-| code-reviewer | Code review | After writing code |
-| security-reviewer | Security analysis | Before commits |
-| build-error-resolver | Fix build errors | When build fails |
-| e2e-runner | E2E testing | Critical user flows |
-| refactor-cleaner | Dead code cleanup | Code maintenance |
-| doc-updater | Documentation | Updating docs |
-| rust-reviewer | Rust code review | Rust projects |
-
-## Immediate Agent Usage
-
-No user prompt needed:
-1. Complex feature requests - Use **planner** agent
-2. Code just written/modified - Use **code-reviewer** agent
-3. Bug fix or new feature - Use **tdd-guide** agent
-4. Architectural decision - Use **architect** agent
-
-## Parallel Task Execution
-
-ALWAYS use parallel Task execution for independent operations:
-
-```markdown
-# GOOD: Parallel execution
-Launch 3 agents in parallel:
-1. Agent 1: Security analysis of auth module
-2. Agent 2: Performance review of cache system
-3. Agent 3: Type checking of utilities
-
-# BAD: Sequential when unnecessary
-First agent 1, then agent 2, then agent 3
+62 specialist agents are available. Intent routing is always-on — describe your problem in plain words and the right agent is invoked automatically. You can also invoke explicitly: `use <agent-name>`.
+
+## Kodelyth Exclusives
+
+| Agent | When to Use |
+|-------|-------------|
+| `kodelyth-advisor` | Not sure where to start — master guide |
+| `pair-programmer` | Before writing code — think through approach first |
+| `debug-detective` | Any bug — evidence-first root cause, never guess-and-check |
+| `silent-failure-hunter` | Bugs that don't throw errors |
+| `incident-commander` | Production incident — P0/P1 triage, contain, postmortem |
+| `load-tester` | Load/stress testing — k6, Locust, Artillery, capacity planning |
+| `kodelyth-memory` | Manage local BM25 memory — recall, capture, review |
+| `image-architect` | AI image generation — Gemini/DALL-E/fal.ai/SVG |
+
+## Planning & Architecture
+
+| Agent | When to Use |
+|-------|-------------|
+| `planner` | Plan a feature before writing a line of code |
+| `architect` | System-level design, dependency graphs |
+| `code-architect` | Code-level architecture decisions |
+| `chief-of-staff` | Strategic decisions, comms, stakeholder updates |
+| `migration-guide` | Framework/language version upgrades, phase by phase |
+
+## Code Review
+
+| Agent | When to Use |
+|-------|-------------|
+| `code-reviewer` | General review after writing code |
+| `typescript-reviewer` | TypeScript / React / Next.js |
+| `python-reviewer` | Python |
+| `go-reviewer` | Go |
+| `rust-reviewer` | Rust |
+| `java-reviewer` | Java / Spring Boot |
+| `kotlin-reviewer` | Kotlin / Android / KMP |
+| `cpp-reviewer` | C++ |
+| `csharp-reviewer` | C# / .NET |
+| `flutter-reviewer` | Flutter / Dart |
+| `database-reviewer` | SQL schema, query patterns, indexes |
+| `healthcare-reviewer` | PHI/HIPAA-aware review for healthcare apps |
+
+## Build Fixers
+
+| Agent | When to Use |
+|-------|-------------|
+| `build-error-resolver` | General build failure |
+| `go-build-resolver` | Go build errors |
+| `rust-build-resolver` | Rust/Cargo build errors |
+| `java-build-resolver` | Java/Maven/Gradle build errors |
+| `kotlin-build-resolver` | Kotlin/Gradle build errors |
+| `cpp-build-resolver` | C++/CMake/Make build errors |
+| `dart-build-resolver` | Dart/Flutter build errors |
+| `pytorch-build-resolver` | PyTorch/CUDA build errors |
+| `dependency-doctor` | npm/pip/cargo/maven dep hell, CVEs, lockfile drift |
+| `env-debugger` | "Works on my machine" — env, config, secrets layers |
+
+## Debugging & Testing
+
+| Agent | When to Use |
+|-------|-------------|
+| `tdd-guide` | Write tests first — TDD methodology |
+| `e2e-runner` | End-to-end test automation |
+| `pr-test-analyzer` | CI output — root cause failing tests |
+| `flake-hunter` | Flaky test stabilization — never blind retries |
+
+## Security & API
+
+| Agent | When to Use |
+|-------|-------------|
+| `security-reviewer` | OWASP top 10, secrets, auth, injection vectors |
+| `api-guardian` | Detect breaking API changes before they ship |
+
+## Performance & Quality
+
+| Agent | When to Use |
+|-------|-------------|
+| `performance-optimizer` | Profiling-first — measure before optimizing |
+| `refactor-cleaner` | Remove code smells, dead code, tech debt |
+| `code-simplifier` | Improve readability without changing behavior |
+| `type-design-analyzer` | TypeScript type system design |
+
+## Documentation & Analysis
+
+| Agent | When to Use |
+|-------|-------------|
+| `doc-updater` | Update or write documentation |
+| `docs-lookup` | Find docs for a library or API |
+| `comment-analyzer` | Audit code comments for accuracy |
+| `code-explorer` | Explore an unfamiliar codebase |
+| `conversation-analyzer` | Analyze conversation or chat patterns |
+
+## Release & Ops
+
+| Agent | When to Use |
+|-------|-------------|
+| `release-captain` | Cut a clean release — semver, tagging, rollback plan |
+| `git-rescue` | Broken git state, lost commits, bad rebase — no history loss |
+
+## Open Source
+
+| Agent | When to Use |
+|-------|-------------|
+| `opensource-forker` | Fork and clean a project for open-source release |
+| `opensource-sanitizer` | Strip secrets, PII, proprietary references |
+| `opensource-packager` | README, license, contribution docs |
+
+## Specialized
+
+| Agent | When to Use |
+|-------|-------------|
+| `ux-reviewer` | UX behavior + WCAG 2.1 AA accessibility |
+| `seo-specialist` | Technical SEO, structured data, rankings |
+
+## GAN Harness (Multi-Agent)
+
+| Agent | When to Use |
+|-------|-------------|
+| `gan-planner` | Plan a GAN-style generator/evaluator workflow |
+| `gan-generator` | Generate output in a GAN harness loop |
+| `gan-evaluator` | Evaluate output and provide adversarial feedback |
+| `harness-optimizer` | Optimize agent harness action spaces |
+| `loop-operator` | Operate autonomous agent loops |
+
+## Parallel Execution
+
+ALWAYS launch independent agents in parallel:
+
+```
+# GOOD: parallel
+use code-reviewer + security-reviewer + ux-reviewer simultaneously
+
+# BAD: sequential when not needed
+code-reviewer → then security-reviewer → then ux-reviewer
 ```
 
-## Multi-Perspective Analysis
+## Standard Handoff Chains
 
-For complex problems, use split role sub-agents:
-- Factual reviewer
-- Senior engineer
-- Security expert
-- Consistency reviewer
-- Redundancy checker
+| Workflow | Chain |
+|----------|-------|
+| New feature | `pair-programmer` → `tdd-guide` → `code-reviewer` → `security-reviewer` |
+| Bug fix | `debug-detective` → `tdd-guide` → `refactor-cleaner` |
+| Production incident | `incident-commander` → `debug-detective` → `tdd-guide` |
+| Open-source | `opensource-forker` → `opensource-sanitizer` → `opensource-packager` → `release-captain` |

package/rules/elixir/coding-style.md

@@ -0,0 +1,46 @@
+---
+paths:
+  - "**/*.ex"
+  - "**/*.exs"
+---
+# Elixir Coding Style
+
+> This file extends [common/coding-style.md](../common/coding-style.md) with Elixir specific content.
+
+## Standards
+
+- Follow the official **Elixir Style Guide**
+- Use **mix format** — non-negotiable, always auto-format
+- All public functions must have `@spec` type annotations and `@doc` documentation
+
+## Immutability
+
+Data is immutable by default in Elixir. Embrace it:
+
+```elixir
+# Use the pipe operator for data transformations
+result =
+  input
+  |> validate()
+  |> transform()
+  |> persist()
+```
+
+## Function Heads Over Conditionals
+
+```elixir
+# Prefer pattern-matched function heads over cond/case at the top level
+def process(%{status: :active} = user), do: activate(user)
+def process(%{status: :banned} = user), do: reject(user)
+def process(_user), do: {:error, :unknown_status}
+```
+
+## Formatting
+
+- **mix format** — run on every save
+- **Credo** for code quality and style checks
+- Line length: 98 characters (mix format default)
+
+## Reference
+
+See skill: `elixir-patterns` for comprehensive GenServer, Phoenix, and OTP patterns.

package/rules/elixir/hooks.md

@@ -0,0 +1,26 @@
+---
+paths:
+  - "**/*.ex"
+  - "**/*.exs"
+---
+# Elixir Hooks
+
+> This file extends [common/hooks.md](../common/hooks.md) with Elixir specific content.
+
+## PostToolUse Hooks
+
+Configure in `~/.claude/settings.json`:
+
+- **mix format**: Auto-format `.ex` / `.exs` files after edit
+  ```bash
+  mix format <file>
+  ```
+- **Credo**: Run on edited files for style warnings
+  ```bash
+  mix credo <file>
+  ```
+
+## Warnings
+
+- Warn when `IO.inspect` is left in non-test `.ex` files (use `Logger` instead)
+- Warn when `dbg()` (Elixir 1.14+) is left in production code paths

package/rules/elixir/patterns.md

@@ -0,0 +1,67 @@
+---
+paths:
+  - "**/*.ex"
+  - "**/*.exs"
+---
+# Elixir Patterns
+
+> This file extends [common/patterns.md](../common/patterns.md) with Elixir specific content.
+
+## with for Multi-Step Operations
+
+```elixir
+def create_user(params) do
+  with {:ok, validated} <- validate(params),
+       {:ok, user} <- Repo.insert(User.changeset(%User{}, validated)),
+       :ok <- send_welcome_email(user) do
+    {:ok, user}
+  end
+end
+```
+
+## GenServer Pattern
+
+```elixir
+defmodule MyApp.Cache do
+  use GenServer
+
+  def start_link(opts), do: GenServer.start_link(__MODULE__, %{}, opts)
+
+  def get(pid, key), do: GenServer.call(pid, {:get, key})
+  def put(pid, key, value), do: GenServer.cast(pid, {:put, key, value})
+
+  @impl true
+  def init(state), do: {:ok, state}
+
+  @impl true
+  def handle_call({:get, key}, _from, state), do: {:reply, Map.get(state, key), state}
+
+  @impl true
+  def handle_cast({:put, key, value}, state), do: {:noreply, Map.put(state, key, value)}
+end
+```
+
+## Context Modules (Phoenix)
+
+```elixir
+defmodule MyApp.Accounts do
+  alias MyApp.Accounts.User
+  alias MyApp.Repo
+
+  def get_user!(id), do: Repo.get!(User, id)
+
+  def create_user(attrs) do
+    %User{}
+    |> User.changeset(attrs)
+    |> Repo.insert()
+  end
+end
+```
+
+## Tagged Tuples for Errors
+
+Always return `{:ok, result}` or `{:error, reason}` — never bare values from functions that can fail.
+
+## Reference
+
+See skill: `phoenix-patterns` for Phoenix LiveView, contexts, and Ecto query patterns.

package/rules/elixir/security.md

@@ -0,0 +1,58 @@
+---
+paths:
+  - "**/*.ex"
+  - "**/*.exs"
+---
+# Elixir Security
+
+> This file extends [common/security.md](../common/security.md) with Elixir specific content.
+
+## Secret Management
+
+```elixir
+# config/runtime.exs — read from environment at runtime, never compile-time
+config :my_app, :stripe_key,
+  System.fetch_env!("STRIPE_SECRET_KEY")  # raises if missing
+```
+
+Never put secrets in `config/config.exs` or `config/dev.exs` committed to git.
+
+## SQL Injection
+
+Always use Ecto parameterized queries:
+
+```elixir
+# UNSAFE — never do this
+Repo.query("SELECT * FROM users WHERE email = '#{email}'")
+
+# SAFE
+from(u in User, where: u.email == ^email) |> Repo.one()
+```
+
+## Atom Exhaustion
+
+Never convert untrusted user input to atoms — the atom table is not garbage collected:
+
+```elixir
+# UNSAFE
+String.to_atom(user_input)
+
+# SAFE
+String.to_existing_atom(user_input)  # only if atom must already exist
+# or keep it as a string
+```
+
+## Security Scanning
+
+- **Sobelow** for Phoenix/Elixir static security analysis:
+  ```bash
+  mix sobelow --config
+  ```
+- **mix audit** for dependency vulnerability scanning:
+  ```bash
+  mix hex.audit
+  ```
+
+## Reference
+
+See skill: `security-review` for OWASP top 10 and authentication patterns.

package/rules/elixir/testing.md

@@ -0,0 +1,64 @@
+---
+paths:
+  - "**/*.ex"
+  - "**/*.exs"
+  - "**/test/**"
+---
+# Elixir Testing
+
+> This file extends [common/testing.md](../common/testing.md) with Elixir specific content.
+
+## Framework
+
+Use **ExUnit** (built-in). Use **Mox** for behaviour-based mocking.
+
+## Structure
+
+```elixir
+defmodule MyApp.AccountsTest do
+  use MyApp.DataCase
+
+  alias MyApp.Accounts
+
+  describe "create_user/1" do
+    test "creates a user with valid attrs" do
+      attrs = %{name: "Alice", email: "alice@example.com"}
+      assert {:ok, user} = Accounts.create_user(attrs)
+      assert user.email == "alice@example.com"
+    end
+
+    test "returns error with invalid attrs" do
+      assert {:error, changeset} = Accounts.create_user(%{})
+      assert "can't be blank" in errors_on(changeset).email
+    end
+  end
+end
+```
+
+## Coverage
+
+```bash
+mix test --cover
+```
+
+Use **excoveralls** for detailed coverage reports:
+
+```bash
+mix coveralls
+mix coveralls.html
+```
+
+## Async Tests
+
+Mark tests as `async: true` when they don't share state:
+
+```elixir
+defmodule MyApp.PureTest do
+  use ExUnit.Case, async: true
+  ...
+end
+```
+
+## Reference
+
+See skill: `elixir-testing` for ExUnit async patterns, Mox setup, and property-based testing with StreamData.

package/rules/ruby/coding-style.md

@@ -0,0 +1,41 @@
+---
+paths:
+  - "**/*.rb"
+  - "**/*.rake"
+  - "**/Gemfile"
+  - "**/Rakefile"
+---
+# Ruby Coding Style
+
+> This file extends [common/coding-style.md](../common/coding-style.md) with Ruby specific content.
+
+## Standards
+
+- Follow the **Ruby Style Guide** (rubocop default)
+- Use **frozen_string_literal: true** at the top of every file
+- Prefer `do...end` for multi-line blocks, `{ }` for single-line
+
+## Immutability
+
+```ruby
+# frozen_string_literal: true
+
+User = Data.define(:name, :email)  # Ruby 3.2+ immutable value object
+```
+
+## Formatting
+
+- **RuboCop** for linting and style enforcement
+- **StandardRB** as a zero-config RuboCop config alternative
+- Line length: 120 characters max
+
+## Naming
+
+- `snake_case` for methods and variables
+- `CamelCase` for classes and modules
+- `SCREAMING_SNAKE_CASE` for constants
+- Predicate methods end with `?`, destructive methods end with `!`
+
+## Reference
+
+See skill: `ruby-patterns` for comprehensive Ruby idioms, Rails patterns, and concurrency.

package/rules/ruby/hooks.md

@@ -0,0 +1,23 @@
+---
+paths:
+  - "**/*.rb"
+  - "**/*.rake"
+---
+# Ruby Hooks
+
+> This file extends [common/hooks.md](../common/hooks.md) with Ruby specific content.
+
+## PostToolUse Hooks
+
+Configure in `~/.claude/settings.json`:
+
+- **RuboCop**: Auto-lint `.rb` files after edit
+  ```bash
+  rubocop --autocorrect <file>
+  ```
+- **Syntax check**: Run `ruby -c <file>` after editing
+
+## Warnings
+
+- Warn about `puts` / `p` statements in non-test `.rb` files (use `Rails.logger` or a logger instead)
+- Warn when `binding.pry` or `byebug` is left in edited files

package/rules/ruby/patterns.md

@@ -0,0 +1,71 @@
+---
+paths:
+  - "**/*.rb"
+  - "**/*.rake"
+---
+# Ruby Patterns
+
+> This file extends [common/patterns.md](../common/patterns.md) with Ruby specific content.
+
+## Service Objects
+
+```ruby
+# frozen_string_literal: true
+
+class CreateUserService
+  def initialize(params)
+    @params = params
+  end
+
+  def call
+    user = User.new(@params)
+    user.save!
+    user
+  end
+end
+
+# Usage
+result = CreateUserService.new(params).call
+```
+
+## Value Objects
+
+```ruby
+# frozen_string_literal: true
+
+Address = Data.define(:street, :city, :country)
+
+address = Address.new(street: "123 Main St", city: "London", country: "UK")
+```
+
+## Query Objects
+
+```ruby
+# frozen_string_literal: true
+
+class ActiveUsersQuery
+  def initialize(relation = User.all)
+    @relation = relation
+  end
+
+  def call
+    @relation.where(status: :active).order(created_at: :desc)
+  end
+end
+```
+
+## Modules for Composition
+
+Prefer composition over inheritance for shared behavior:
+
+```ruby
+module Auditable
+  def self.included(base)
+    base.before_action :track_activity
+  end
+end
+```
+
+## Reference
+
+See skill: `rails-patterns` for Rails-specific patterns including concerns, callbacks, and ActiveRecord best practices.

package/rules/ruby/security.md

@@ -0,0 +1,56 @@
+---
+paths:
+  - "**/*.rb"
+  - "**/*.rake"
+---
+# Ruby Security
+
+> This file extends [common/security.md](../common/security.md) with Ruby specific content.
+
+## Secret Management
+
+```ruby
+# Never hardcode secrets
+api_key = ENV.fetch("STRIPE_SECRET_KEY")  # raises KeyError if missing, not nil
+
+# Rails credentials (encrypted)
+Rails.application.credentials.stripe[:secret_key]
+```
+
+## SQL Injection
+
+Always use parameterized queries — never string interpolation:
+
+```ruby
+# UNSAFE
+User.where("email = '#{params[:email]}'")
+
+# SAFE
+User.where(email: params[:email])
+User.where("email = ?", params[:email])
+```
+
+## Mass Assignment
+
+Use strong parameters in Rails controllers:
+
+```ruby
+def user_params
+  params.require(:user).permit(:name, :email)
+end
+```
+
+## Security Scanning
+
+- **Brakeman** for static security analysis of Rails apps:
+  ```bash
+  brakeman -q
+  ```
+- **bundler-audit** for dependency CVE scanning:
+  ```bash
+  bundle audit check --update
+  ```
+
+## Reference
+
+See skill: `security-review` for OWASP top 10 and auth patterns.