@mohammadhprp/system-prompt 0.10.1

package/framework/skills/jira-mcp/references/issues.md

@@ -0,0 +1,97 @@
+# Issue Management
+
+## Create
+
+```
+create_issue
+  projectKey: "PROJ"
+  summary: "Login page returns 500"
+  issueType: "Bug"
+  description: "Steps to reproduce..."
+  priority: "High"
+  labels: ["bug", "critical"]
+  assignee: "john.doe"
+  components: ["frontend"]
+  customfield_10211: "Sprint 1"    # optional custom fields
+```
+
+Always verify project and issue types first:
+
+1. `get_projects` → find project key
+2. `get_issue_types` with `projectKey: "PROJ"` → find valid types
+3. `create_issue` with valid `projectKey` and `issueType`
+
+## Read
+
+```
+get_issue
+  issueKey: "PROJ-123"
+```
+
+Returns full issue details: summary, description, status, priority, assignee, reporter, labels, components, custom fields, timestamps.
+
+## Search (JQL)
+
+```
+search_issues
+  jql: "project = PROJ AND status = Open"
+  maxResults: 50
+```
+
+### Common JQL Patterns
+
+| Purpose | JQL |
+| ------- | --- |
+| My open issues | `assignee = currentUser() AND status != Done` |
+| High priority recent | `priority = High AND created >= -7d` |
+| By status | `status IN (Open, "In Progress", "Reopened")` |
+| By label | `labels = "bug" OR labels = "critical"` |
+| By reporter | `reporter = john.doe AND status NOT IN (Closed, Done)` |
+| Unassigned | `assignee IS NULL AND status NOT IN (Closed, Done, Resolved)` |
+| Sprints (custom field) | `cf[10211] = "Sprint 1"` |
+| Date range | `created >= "2025-01-01" AND created <= "2025-06-01"` |
+| Order by | `project = PROJ ORDER BY priority DESC, created ASC` |
+| Text search | `text ~ "error message"` |
+| Across all projects | `status = Open AND assignee = currentUser()` |
+
+`search_issues` defaults to showing issues across **all projects** the user has access to. Scope to a specific project with `project = KEY`.
+
+## Update
+
+```
+update_issue
+  issueKey: "PROJ-123"
+  summary: "Updated title"
+  description: "New description"
+  priority: "Low"
+  assignee: "jane.doe"
+  labels: ["bug", "resolved"]
+  status: "In Progress"           # transition to new status
+  customfield_10211: "Sprint 2"
+```
+
+### Status Transitions
+
+- Issue workflow statuses depend on the project's configuration
+- Common transitions: `Open → "In Progress" → "In Review" → "Done" | "Closed"`
+- Use `get_issue` to check current status and `update_issue` with `status` to transition
+- Invalid transitions return an error — check the project's available workflow transitions in Jira
+
+## Assign
+
+```
+assign_issue
+  issueKey: "PROJ-123"
+  assignee: "john.doe"
+```
+
+`assign_issue` is a dedicated tool. You can also assign via `update_issue` with `assignee`.
+
+## Delete
+
+```
+delete_issue
+  issueKey: "PROJ-123"
+```
+
+**Warning**: `delete_issue` is destructive — permanently deletes the issue. Cannot be undone.

package/framework/skills/jira-mcp/references/projects.md

@@ -0,0 +1,39 @@
+# Project Management
+
+## List Projects
+
+```
+get_projects
+```
+
+Returns all Jira projects the authenticated user can access. Each entry includes `key`, `name`, `projectTypeKey`, `lead`, and `avatarUrls`.
+
+Use this to discover available `projectKey` values for issue operations.
+
+## Project Details
+
+```
+get_project
+  projectKey: "PROJ"
+```
+
+Returns detailed information: name, key, description, lead, components, versions (releases), project type, and category.
+
+Verify a project exists and inspect its components/versions before creating issues:
+
+1. `get_project` → check components, versions
+2. `get_issue_types` → check valid issue types
+3. `create_issue` with verified data
+
+## Issue Types
+
+```
+get_issue_types
+  projectKey: "PROJ"
+```
+
+Returns available issue types for a project. Each type includes `name`, `id`, `description`, `iconUrl`, and `subtask` flag.
+
+Common types across most projects: `Bug`, `Task`, `Story`, `Epic`, `Sub-task`, `Improvement`, `New Feature`.
+
+Always call this **before** creating an issue to ensure the `issueType` value is valid for the target project.

package/framework/skills/laravel-best-practices/SKILL.md

@@ -0,0 +1,229 @@
+---
+name: laravel-best-practices
+description: "Apply this skill whenever writing, reviewing, or refactoring Laravel PHP code."
+version: 0.1.0
+---
+
+# Laravel Best Practices
+
+Best practices for Laravel, prioritized by impact. Each rule teaches what to do and why. For exact API syntax, verify with `search-docs`.
+
+## Consistency First
+
+Before applying any rule, check what the application already does. Laravel offers multiple valid approaches — the best choice is the one the codebase already uses, even if another pattern would be theoretically better. Inconsistency is worse than a suboptimal pattern.
+
+Check sibling files, related controllers, models, or tests for established patterns. If one exists, follow it — don't introduce a second way. These rules are defaults for when no pattern exists yet, not overrides.
+
+## Quick Reference
+
+### 1. Database Performance → `references/db-performance.md`
+
+- Eager load with `with()` to prevent N+1 queries
+- Enable `Model::preventLazyLoading()` in development
+- Select only needed columns, avoid `SELECT *`
+- `chunk()` / `chunkById()` for large datasets
+- Index columns used in `WHERE`, `ORDER BY`, `JOIN`
+- `withCount()` instead of loading relations to count
+- `cursor()` for memory-efficient read-only iteration
+- Never query in Blade templates
+
+### 2. Advanced Query Patterns → `references/advanced-queries.md`
+
+- `addSelect()` subqueries over eager-loading entire has-many for a single value
+- Dynamic relationships via subquery FK + `belongsTo`
+- Conditional aggregates (`CASE WHEN` in `selectRaw`) over multiple count queries
+- `setRelation()` to prevent circular N+1 queries
+- `whereIn` + `pluck()` over `whereHas` for better index usage
+- Two simple queries can beat one complex query
+- Compound indexes matching `orderBy` column order
+- Correlated subqueries in `orderBy` for has-many sorting (avoid joins)
+
+### 3. Security → `references/security.md`, `references/passport.md`, `references/spatie-laravel-permission.md`
+
+- Define `$fillable` or `$guarded` on every model, authorize every action via policies or gates
+- No raw SQL with user input — use Eloquent or query builder
+- `{{ }}` for output escaping, `@csrf` on all POST/PUT/DELETE forms, `throttle` on auth and API routes
+- Validate MIME type, extension, and size for file uploads
+- Never commit `.env`, use `config()` for secrets, `encrypted` cast for sensitive DB fields
+
+### 4. Caching → `references/caching.md`
+
+- `Cache::remember()` over manual get/put
+- `Cache::flexible()` for stale-while-revalidate on high-traffic data
+- `Cache::memo()` to avoid redundant cache hits within a request
+- Cache tags to invalidate related groups
+- `Cache::add()` for atomic conditional writes
+- `once()` to memoize per-request or per-object lifetime
+- `Cache::lock()` / `lockForUpdate()` for race conditions
+- Failover cache stores in production
+
+### 5. Eloquent Patterns → `references/eloquent.md`
+
+- Correct relationship types with return type hints
+- Local scopes for reusable query constraints
+- Global scopes sparingly — document their existence
+- Attribute casts in the `casts()` method
+- Cast date columns, use Carbon instances in templates
+- `whereBelongsTo($model)` for cleaner queries
+- Never hardcode table names — use `(new Model)->getTable()` or Eloquent queries
+
+### 6. Validation & Forms → `references/validation.md`
+
+- Form Request classes, not inline validation
+- Array notation `['required', 'email']` for new code; follow existing convention
+- `$request->validated()` only — never `$request->all()`
+- `Rule::when()` for conditional validation
+- `after()` instead of `withValidator()`
+
+### 7. Configuration → `references/config.md`
+
+- `env()` only inside config files
+- `App::environment()` or `app()->isProduction()`
+- Config, lang files, and constants over hardcoded text
+
+### 8. Testing Patterns → `references/testing.md`, `references/pest-testing.md`
+
+- `LazilyRefreshDatabase` over `RefreshDatabase` for speed
+- `assertModelExists()` over raw `assertDatabaseHas()`
+- Factory states and sequences over manual overrides
+- Use fakes (`Event::fake()`, `Exceptions::fake()`, etc.) — but always after factory setup, not before
+- `recycle()` to share relationship instances across factories
+
+### 9. Queue & Job Patterns → `references/queue-jobs.md`
+
+- `retry_after` must exceed job `timeout`; use exponential backoff `[1, 5, 10]`
+- `ShouldBeUnique` to prevent duplicates; `ShouldBeUniqueUntilProcessing` for early lock release
+- Always implement `failed()`; with `retryUntil()`, set `$tries = 0`
+- `RateLimited` middleware for external API calls; `Bus::batch()` for related jobs
+- Horizon for complex multi-queue scenarios
+
+### 10. Routing & Controllers → `references/routing.md`
+
+- Implicit route model binding
+- Scoped bindings for nested resources
+- `Route::resource()` or `apiResource()`
+- Methods under 10 lines — extract to actions/services
+- Type-hint Form Requests for auto-validation
+
+### 11. HTTP Client → `references/http-client.md`
+
+- Explicit `timeout` and `connectTimeout` on every request
+- `retry()` with exponential backoff for external APIs
+- Check response status or use `throw()`
+- `Http::pool()` for concurrent independent requests
+- `Http::fake()` and `preventStrayRequests()` in tests
+
+### 12. Events, Notifications & Mail → `references/events-notifications.md`, `references/mail.md`
+
+- Event discovery over manual registration; `event:cache` in production
+- `ShouldDispatchAfterCommit` / `afterCommit()` inside transactions
+- Queue notifications and mailables with `ShouldQueue`
+- On-demand notifications for non-user recipients
+- `HasLocalePreference` on notifiable models
+- `assertQueued()` not `assertSent()` for queued mailables
+- Markdown mailables for transactional emails
+
+### 13. Error Handling → `references/error-handling.md`
+
+- `report()`/`render()` on exception classes or in `bootstrap/app.php` — follow existing pattern
+- `ShouldntReport` for exceptions that should never log
+- Throttle high-volume exceptions to protect log sinks
+- `dontReportDuplicates()` for multi-catch scenarios
+- Force JSON rendering for API routes
+- Structured context via `context()` on exception classes
+
+### 14. Task Scheduling → `references/scheduling.md`
+
+- `withoutOverlapping()` on variable-duration tasks
+- `onOneServer()` on multi-server deployments
+- `runInBackground()` for concurrent long tasks
+- `environments()` to restrict to appropriate environments
+- `takeUntilTimeout()` for time-bounded processing
+- Schedule groups for shared configuration
+
+### 15. Architecture → `references/architecture.md`
+
+- Single-purpose Action classes; dependency injection over `app()` helper
+- Prefer official Laravel packages and follow conventions, don't override defaults
+- Default to `ORDER BY id DESC` or `created_at DESC`; `mb_*` for UTF-8 safety
+- `defer()` for post-response work; `Context` for request-scoped data; `Concurrency::run()` for parallel execution
+
+### 16. Migrations → `references/migrations.md`
+
+- Generate migrations with `php artisan make:migration`
+- `constrained()` for foreign keys
+- Never modify migrations that have run in production
+- Add indexes in the migration, not as an afterthought
+- Mirror column defaults in model `$attributes`
+- Reversible `down()` by default; forward-fix migrations for intentionally irreversible changes
+- One concern per migration — never mix DDL and DML
+
+### 17. Collections → `references/collections.md`
+
+- Higher-order messages for simple collection operations
+- `cursor()` vs. `lazy()` — choose based on relationship needs
+- `lazyById()` when updating records while iterating
+- `toQuery()` for bulk operations on collections
+
+### 18. Blade & Views → `references/blade-views.md`, `references/tailwindcss.md`
+
+- `$attributes->merge()` in component templates
+- Blade components over `@include`; `@pushOnce` for per-component scripts
+- View Composers for shared view data
+- `@aware` for deeply nested component props
+
+### 19. Conventions & Style → `references/style.md`
+
+- Follow Laravel naming conventions for all entities
+- Prefer Laravel helpers (`Str`, `Arr`, `Number`, `Uri`, `Str::of()`, `$request->string()`) over raw PHP functions
+- No JS/CSS in Blade, no HTML in PHP classes
+- Code should be readable; comments only for config files
+
+### 20. Feature Flags → `references/pennant.md`
+
+- `Feature::define()` to define features with resolver callbacks
+- `Feature::active()` / `@feature` Blade directive to check features
+- Scope features to specific users/entities with `Feature::for()`
+- `Feature::activate()` / `deactivate()` for runtime control
+
+### 21. Monitoring → `references/pulse.md`
+
+- Gate-protect the dashboard with `viewPulse` gate
+- Configure built-in recorders in `config/pulse.php` (SlowQueries, SlowRequests, Exceptions, Queues, etc.)
+- Redis ingest for production performance; run `pulse:work` to drain the stream
+- Custom cards via Livewire components extending `Pulse\Card`
+- `Pulse::filter()` to exclude entries; `Pulse::resolveAuthenticatedUserId()` for multi-model apps
+- `pulse:check` daemon required for Servers card
+
+### 22. Full-Text Search → `references/scout.md`
+
+- Add `Searchable` trait to models for automatic index sync
+- Choose engine: Database, Collection, Algolia, Meilisearch, Typesense
+- `toSearchableArray()` to control indexed data; `searchableAs()` for custom index names
+- `Model::search('query')->where(...)->paginate()` for search queries
+- `scout:import` / `scout:flush` for index management; `scout:sync-index-settings` for engine config
+- `Model::withoutSyncingToSearch()` / `SCOUT_DRIVER=null` for testing
+
+### 23. Backup → `references/spatie-laravel-backup.md`
+
+- Schedule `backup:run`, `backup:clean`, `backup:monitor` in console kernel
+- Configure sources, destinations, notifications in `config/backup.php`
+- Custom cleanup strategies extending `CleanupStrategy`
+- Custom health checks extending `HealthCheck`
+- Enable encryption and Gzip compression via config
+
+### 24. Media Library → `references/spatie-medialibrary.md`
+
+- Implement `HasMedia` interface + `InteractsWithMedia` trait on models
+- `addMedia()` / `addMediaFromRequest()` for file uploads
+- Media collections to organize related files per model
+- Conversions for image processing (thumbnails, crops, etc.)
+- Responsive images via conversion `withResponsiveImages()`
+
+## How to Apply
+
+Always use a sub-agent to read rule files and explore this skill's content.
+
+1. Identify the file type and select relevant sections (e.g., migration → §16, controller → §1, §3, §5, §6, §10)
+2. Check sibling files for existing patterns — follow those first per Consistency First
+3. Verify API syntax with `search-docs` for the installed Laravel version

package/framework/skills/laravel-best-practices/examples.md

@@ -0,0 +1,31 @@
+# Laravel Best Practices Examples
+
+## Example 1: Refactor Controller Logic
+
+A controller action contains five responsibilities: validation, authorization, querying, formatting, and logging. Good agent behavior:
+
+- Extract validation into a Form Request class with `authorize()` and `rules()` methods.
+- Move authorization checks into a Policy class with a named method matching the action.
+- Extract query logic into a repository or service class with a single responsibility.
+- Use API resources for response formatting instead of inline `toArray()` calls.
+- Use Laravel's built-in logging channel with structured context instead of `Log::debug()` scattered through the controller.
+
+## Example 2: Fix N+1 Query Performance
+
+A page loads slowly because a loop calls a relationship query for every item. Good agent behavior:
+
+- Identify the N+1 pattern: the loop accesses `$post->comments` inside a Blade `@foreach`.
+- Use `$posts->load('comments')` for eager loading, or use `with('comments')` on the initial query.
+- Check for deeper nested relationships that would cause additional N+1 patterns.
+- Add `select` and `where` constraints on the eager-loaded relationship to avoid fetching unnecessary data.
+- Verify the fix reduces query count from N+1 to 2 with `DB::enableQueryLog`.
+
+## Example 3: Secure API Endpoint
+
+An API endpoint allows any authenticated user to delete any order. Good agent behavior:
+
+- Create a Policy with a `delete` method that verifies the order belongs to the user.
+- Register the policy in `AuthServiceProvider`.
+- Use `$this->authorize('delete', $order)` in the controller instead of inline `if` checks.
+- Add a Form Request to validate the delete action input (order ID, reason).
+- Write a unit test for the policy denying access to orders owned by other users.

package/framework/skills/laravel-best-practices/references/advanced-queries.md

@@ -0,0 +1,106 @@
+# Advanced Query Patterns
+
+## Use `addSelect()` Subqueries for Single Values from Has-Many
+
+Instead of eager-loading an entire has-many relationship for a single value (like the latest timestamp), use a correlated subquery via `addSelect()`. This pulls the value directly in the main SQL query — zero extra queries.
+
+```php
+public function scopeWithLastLoginAt($query): void
+{
+    $query->addSelect([
+        'last_login_at' => Login::select('created_at')
+            ->whereColumn('user_id', 'users.id')
+            ->latest()
+            ->take(1),
+    ])->withCasts(['last_login_at' => 'datetime']);
+}
+```
+
+## Create Dynamic Relationships via Subquery FK
+
+Extend the `addSelect()` pattern to fetch a foreign key via subquery, then define a `belongsTo` relationship on that virtual attribute. This provides a fully-hydrated related model without loading the entire collection.
+
+```php
+public function lastLogin(): BelongsTo
+{
+    return $this->belongsTo(Login::class);
+}
+
+public function scopeWithLastLogin($query): void
+{
+    $query->addSelect([
+        'last_login_id' => Login::select('id')
+            ->whereColumn('user_id', 'users.id')
+            ->latest()
+            ->take(1),
+    ])->with('lastLogin');
+}
+```
+
+## Use Conditional Aggregates Instead of Multiple Count Queries
+
+Replace N separate `count()` queries with a single query using `CASE WHEN` inside `selectRaw()`. Use `toBase()` to skip model hydration when you only need scalar values.
+
+```php
+$statuses = Feature::toBase()
+    ->selectRaw("count(case when status = 'Requested' then 1 end) as requested")
+    ->selectRaw("count(case when status = 'Planned' then 1 end) as planned")
+    ->selectRaw("count(case when status = 'Completed' then 1 end) as completed")
+    ->first();
+```
+
+## Use `setRelation()` to Prevent Circular N+1
+
+When a parent model is eager-loaded with its children, and the view also needs `$child->parent`, use `setRelation()` to inject the already-loaded parent rather than letting Eloquent fire N additional queries.
+
+```php
+$feature->load('comments.user');
+$feature->comments->each->setRelation('feature', $feature);
+```
+
+## Prefer `whereIn` + Subquery Over `whereHas`
+
+`whereHas()` emits a correlated `EXISTS` subquery that re-executes per row. Using `whereIn()` with a `select('id')` subquery lets the database use an index lookup instead, without loading data into PHP memory.
+
+Incorrect (correlated EXISTS re-executes per row):
+
+```php
+$query->whereHas('company', fn ($q) => $q->where('name', 'like', $term));
+```
+
+Correct (index-friendly subquery, no PHP memory overhead):
+
+```php
+$query->whereIn('company_id', Company::where('name', 'like', $term)->select('id'));
+```
+
+## Sometimes Two Simple Queries Beat One Complex Query
+
+Running a small, targeted secondary query and passing its results via `whereIn` is often faster than a single complex correlated subquery or join. The additional round-trip is worthwhile when the secondary query is highly selective and uses its own index.
+
+## Use Compound Indexes Matching `orderBy` Column Order
+
+When ordering by multiple columns, create a single compound index in the same column order as the `ORDER BY` clause. Individual single-column indexes cannot combine for multi-column sorts — the database will filesort without a compound index.
+
+```php
+// Migration
+$table->index(['last_name', 'first_name']);
+
+// Query — column order must match the index
+User::query()->orderBy('last_name')->orderBy('first_name')->paginate();
+```
+
+## Use Correlated Subqueries for Has-Many Ordering
+
+When sorting by a value from a has-many relationship, avoid joins (they duplicate rows). Use a correlated subquery inside `orderBy()` instead, paired with an `addSelect` scope for eager loading.
+
+```php
+public function scopeOrderByLastLogin($query): void
+{
+    $query->orderByDesc(Login::select('created_at')
+        ->whereColumn('user_id', 'users.id')
+        ->latest()
+        ->take(1)
+    );
+}
+```