1---2name: codeprobe-solid3description: Audits code for SOLID principle violations — Single Responsibility, Open/Closed, Liskov Substitution, Interface Segregation, and Dependency Inversion. Identifies classes and methods that violate these principles and generates fix prompts. Trigger phrases: "SOLID check", "solid review", "SRP violation", "dependency inversion".4---56## Standalone Mode78If invoked directly (not via the orchestrator), you must first:91. Read `../codeprobe/shared-preamble.md` (resolve relative to this SKILL.md's location — the sibling `codeprobe` skill directory — not the user's project) for the output contract, execution modes, and constraints.102. Load applicable reference files from `../codeprobe/references/` (same resolution) based on the project's tech stack.113. Default to `full` mode unless the user specifies otherwise.1213# SOLID Principles Auditor1415## Domain Scope1617This sub-skill detects violations of the five SOLID principles:18191. **Single Responsibility Principle (SRP)** — A class or module should have only one reason to change.202. **Open/Closed Principle (OCP)** — Software entities should be open for extension but closed for modification.213. **Liskov Substitution Principle (LSP)** — Subtypes must be substitutable for their base types without altering program correctness.224. **Interface Segregation Principle (ISP)** — Clients should not be forced to depend on interfaces they do not use.235. **Dependency Inversion Principle (DIP)** — High-level modules should not depend on low-level modules; both should depend on abstractions.2425---2627## What It Does NOT Flag2829- **Simple DTOs/value objects** with multiple fields — having many properties is not an SRP violation when the class represents a single data concept.30- **Small scripts and CLIs** that don't need dependency injection — proportional design matters.31- **Enums used in switches** where the enum is stable and closed (e.g., compass directions, days of the week) — OCP applies when variants are likely to grow.32- **Framework-generated classes** following framework conventions (e.g., Laravel migrations, Django admin classes, Rails ActiveRecord models with standard callbacks).33- **Test helper classes** that aggregate setup utilities — test infrastructure has different design constraints.3435---3637## Detection Instructions3839### SRP — Single Responsibility Principle4041| ID Prefix | Signal | How to Detect | Severity |42|-----------|--------|---------------|----------|43| `SRP` | Class has 5+ public methods doing unrelated things | Count public methods. If 5+ exist, check whether they cluster around a single responsibility or span multiple concerns (e.g., authentication + email + database). Look for method name prefixes that suggest different domains. | Major |44| `SRP` | Method exceeds 30 LOC doing multiple concerns | Count lines in each method (excluding blank lines and comments). If > 30 LOC, check whether the method handles multiple distinct steps (validation, transformation, persistence, notification) that could be extracted. | Minor |45| `SRP` | Class name is vague | Flag classes named `Manager`, `Handler`, `Utils`, `Helper`, `Processor`, `Service` (when not domain-qualified) — these names suggest the class has no clear single purpose. Exception: if the class is small (< 5 methods, < 100 LOC), downgrade to suggestion. | Minor |46| `SRP` | Constructor takes 5+ dependencies | Count constructor parameters or injected dependencies. 5+ dependencies suggest the class has too many responsibilities. Check whether dependencies serve different domains. | Major |4748### OCP — Open/Closed Principle4950| ID Prefix | Signal | How to Detect | Severity |51|-----------|--------|---------------|----------|52| `OCP` | Switch/if-else chains on type or status | Look for `switch`/`if-else` chains that branch on a type, status, role, or kind field — especially where adding a new variant requires modifying this block. Count the number of cases: 3+ cases on a growable type is a signal. | Major |53| `OCP` | No extension point where variants are likely to grow | When a switch/if-else on type is found, check whether there is an interface, abstract class, strategy pattern, or plugin mechanism that would allow adding new variants without modifying the existing code. If absent, flag it. | Minor |5455### LSP — Liskov Substitution Principle5657| ID Prefix | Signal | How to Detect | Severity |58|-----------|--------|---------------|----------|59| `LSP` | Subclass overrides method but changes semantics | Check overridden methods: does the subclass return a fundamentally different type, change the meaning of the return value, or produce side effects the parent does not? Compare method signatures and doc comments. | Major |60| `LSP` | Subclass throws exception parent doesn't declare | Look for overridden methods that throw exceptions not present in the parent's throws clause or documented contract. In dynamic languages, look for `raise`/`throw` in overrides where the parent method doesn't throw. | Major |61| `LSP` | Subclass ignores or no-ops parent behavior | Look for overridden methods with empty bodies, `pass`, `return null`, `return`, or `// not implemented` comments. The subclass is refusing the parent's contract. | Minor |62| `LSP` | `instanceof`/type checks after polymorphic call | Search for `instanceof`, `is_a`, `typeof`, `type()`, `is` checks on objects that should be used polymorphically. If code calls a method on a base type and then checks the concrete type, it signals broken substitutability. | Major |6364### ISP — Interface Segregation Principle6566| ID Prefix | Signal | How to Detect | Severity |67|-----------|--------|---------------|----------|68| `ISP` | Interface has 8+ methods | Count methods declared in each interface/abstract class/protocol. If 8+, the interface is likely too broad. Check whether the methods cluster into distinct groups. | Minor |69| `ISP` | Class implements interface but leaves methods empty or throwing | Look for interface implementations where one or more methods are empty, return null, throw `NotImplementedError`/`UnsupportedOperationException`, or contain only `pass`/`TODO` comments. | Major |70| `ISP` | Multiple unrelated method groups in one interface | Analyze the interface's methods: do they fall into 2+ distinct responsibility groups (e.g., read operations + write operations + notification methods)? If so, the interface should be split. | Major |7172### DIP — Dependency Inversion Principle7374| ID Prefix | Signal | How to Detect | Severity |75|-----------|--------|---------------|----------|76| `DIP` | `new ConcreteClass()` inside business logic | Search for direct instantiation (`new ClassName()`, direct constructor calls) of infrastructure or service classes inside business logic methods. Exclude: DTOs, value objects, exceptions, collections, factories, and DI container registrations. | Major |77| `DIP` | High-level module imports from infrastructure layer directly | Check import statements: does a domain/business logic module import directly from database drivers, HTTP clients, file system libraries, or third-party SDKs without an abstraction layer? Look for patterns like `import mysql`, `use Illuminate\Support\Facades\DB`, `from requests import`. | Major |78| `DIP` | No constructor injection — static method calls to concrete dependencies | Look for static method calls like `Database::query()`, `Cache::get()`, `Logger.log()` in business logic where no interface is injected. The class is tightly coupled to the concrete implementation via static access. | Minor |7980---8182## ID Prefixes & Fix Prompt Examples8384- `SRP-` — Single Responsibility Principle violations85- `OCP-` — Open/Closed Principle violations86- `LSP-` — Liskov Substitution Principle violations87- `ISP-` — Interface Segregation Principle violations88- `DIP-` — Dependency Inversion Principle violations8990Number findings sequentially within each prefix: `SRP-001`, `SRP-002`, `OCP-001`, etc.9192### Fix Prompt Examples9394- "Refactor `src/OrderService.php`: extract payment logic (lines 45-78) into a new `PaymentService` class. Inject `PaymentService` via constructor into `OrderService`. Move methods `calculateTotal()`, `applyDiscount()`, and `processPayment()` to the new class."95- "Replace the switch on `$type` in `NotificationSender` (lines 30-65) with a Strategy pattern: create a `NotificationChannel` interface with a `send(Message $message)` method. Create `EmailChannel`, `SmsChannel`, and `PushChannel` implementations. Use a `NotificationChannelFactory` to resolve the correct channel by type."96- "In `UserRepository.php`, replace `new MySqlConnection()` at line 23 with constructor injection: add a `DatabaseConnectionInterface $connection` parameter to the constructor and use it instead of the concrete instantiation."
nishilbhave