autoworkflow 3.1.4 → 3.5.0

package/.claude/skills/laravel.md

@@ -0,0 +1,414 @@
+# Laravel Skill
+
+## Route Definition
+\`\`\`php
+<?php
+// routes/api.php
+
+use App\\Http\\Controllers\\Api\\V1\\UserController;
+
+Route::prefix('v1')->group(function () {
+    // Public routes
+    Route::post('auth/login', [AuthController::class, 'login']);
+    Route::post('auth/register', [AuthController::class, 'register']);
+
+    // Protected routes
+    Route::middleware('auth:sanctum')->group(function () {
+        Route::apiResource('users', UserController::class);
+        Route::get('users/{user}/posts', [UserController::class, 'posts']);
+    });
+});
+\`\`\`
+
+## Controller
+\`\`\`php
+<?php
+
+namespace App\\Http\\Controllers\\Api\\V1;
+
+use App\\Http\\Controllers\\Controller;
+use App\\Http\\Requests\\CreateUserRequest;
+use App\\Http\\Requests\\UpdateUserRequest;
+use App\\Http\\Resources\\UserResource;
+use App\\Http\\Resources\\UserCollection;
+use App\\Models\\User;
+use Illuminate\\Http\\JsonResponse;
+use Illuminate\\Http\\Response;
+
+final class UserController extends Controller
+{
+    public function index(): UserCollection
+    {
+        $users = User::query()
+            ->where('is_active', true)
+            ->latest()
+            ->paginate();
+
+        return new UserCollection($users);
+    }
+
+    public function show(User $user): UserResource
+    {
+        return new UserResource($user->load(['profile', 'roles']));
+    }
+
+    public function store(CreateUserRequest $request): JsonResponse
+    {
+        $user = User::create([
+            ...$request->validated(),
+            'password' => bcrypt($request->password),
+        ]);
+
+        return (new UserResource($user))
+            ->response()
+            ->setStatusCode(Response::HTTP_CREATED);
+    }
+
+    public function update(UpdateUserRequest $request, User $user): UserResource
+    {
+        $user->update($request->validated());
+
+        return new UserResource($user);
+    }
+
+    public function destroy(User $user): Response
+    {
+        $user->delete();
+
+        return response()->noContent();
+    }
+}
+\`\`\`
+
+## Form Request Validation
+\`\`\`php
+<?php
+
+namespace App\\Http\\Requests;
+
+use Illuminate\\Foundation\\Http\\FormRequest;
+use Illuminate\\Validation\\Rules\\Password;
+
+final class CreateUserRequest extends FormRequest
+{
+    public function authorize(): bool
+    {
+        return true;  // Or check permissions
+    }
+
+    public function rules(): array
+    {
+        return [
+            'email' => ['required', 'email', 'max:255', 'unique:users'],
+            'name' => ['required', 'string', 'min:2', 'max:100'],
+            'password' => ['required', 'confirmed', Password::defaults()],
+            'role' => ['sometimes', 'string', 'in:user,admin'],
+        ];
+    }
+
+    public function messages(): array
+    {
+        return [
+            'email.unique' => 'This email is already registered.',
+        ];
+    }
+
+    protected function prepareForValidation(): void
+    {
+        $this->merge([
+            'email' => strtolower($this->email),
+        ]);
+    }
+}
+\`\`\`
+
+## API Resources
+\`\`\`php
+<?php
+
+namespace App\\Http\\Resources;
+
+use Illuminate\\Http\\Request;
+use Illuminate\\Http\\Resources\\Json\\JsonResource;
+
+final class UserResource extends JsonResource
+{
+    public function toArray(Request $request): array
+    {
+        return [
+            'id' => $this->id,
+            'email' => $this->email,
+            'name' => $this->name,
+            'is_active' => $this->is_active,
+            'created_at' => $this->created_at->toISOString(),
+
+            // Conditional relationships
+            'profile' => new ProfileResource($this->whenLoaded('profile')),
+            'roles' => RoleResource::collection($this->whenLoaded('roles')),
+            'posts_count' => $this->when(
+                $this->posts_count !== null,
+                $this->posts_count
+            ),
+        ];
+    }
+}
+
+// Collection with pagination metadata
+final class UserCollection extends ResourceCollection
+{
+    public function toArray(Request $request): array
+    {
+        return [
+            'data' => $this->collection,
+            'meta' => [
+                'current_page' => $this->currentPage(),
+                'per_page' => $this->perPage(),
+                'total' => $this->total(),
+                'last_page' => $this->lastPage(),
+            ],
+        ];
+    }
+}
+\`\`\`
+
+## Eloquent Model
+\`\`\`php
+<?php
+
+namespace App\\Models;
+
+use Illuminate\\Database\\Eloquent\\Factories\\HasFactory;
+use Illuminate\\Database\\Eloquent\\Model;
+use Illuminate\\Database\\Eloquent\\Relations\\HasMany;
+use Illuminate\\Database\\Eloquent\\Relations\\HasOne;
+use Illuminate\\Database\\Eloquent\\Relations\\BelongsToMany;
+use Illuminate\\Database\\Eloquent\\SoftDeletes;
+use Illuminate\\Database\\Eloquent\\Builder;
+
+final class User extends Model
+{
+    use HasFactory, SoftDeletes;
+
+    protected $fillable = [
+        'email',
+        'name',
+        'password',
+        'is_active',
+    ];
+
+    protected $hidden = [
+        'password',
+    ];
+
+    protected $casts = [
+        'is_active' => 'boolean',
+        'email_verified_at' => 'datetime',
+    ];
+
+    // Relationships
+    public function profile(): HasOne
+    {
+        return $this->hasOne(Profile::class);
+    }
+
+    public function posts(): HasMany
+    {
+        return $this->hasMany(Post::class, 'author_id');
+    }
+
+    public function roles(): BelongsToMany
+    {
+        return $this->belongsToMany(Role::class)->withTimestamps();
+    }
+
+    // Scopes
+    public function scopeActive(Builder $query): Builder
+    {
+        return $query->where('is_active', true);
+    }
+
+    public function scopeWithRole(Builder $query, string $role): Builder
+    {
+        return $query->whereHas('roles', fn($q) => $q->where('name', $role));
+    }
+
+    // Accessors
+    protected function email(): Attribute
+    {
+        return Attribute::make(
+            get: fn(string $value) => strtolower($value),
+            set: fn(string $value) => strtolower($value),
+        );
+    }
+
+    // Query methods
+    public static function findByEmail(string $email): ?self
+    {
+        return self::where('email', strtolower($email))->first();
+    }
+}
+\`\`\`
+
+## Service Pattern
+\`\`\`php
+<?php
+
+namespace App\\Services;
+
+use App\\Models\\User;
+use App\\DTOs\\CreateUserData;
+use Illuminate\\Support\\Facades\\DB;
+use Illuminate\\Support\\Facades\\Hash;
+
+final class UserService
+{
+    public function __construct(
+        private readonly NotificationService $notifications,
+    ) {}
+
+    public function create(CreateUserData $data): User
+    {
+        return DB::transaction(function () use ($data) {
+            $user = User::create([
+                'email' => $data->email,
+                'name' => $data->name,
+                'password' => Hash::make($data->password),
+            ]);
+
+            if ($data->role) {
+                $user->roles()->attach(Role::findByName($data->role));
+            }
+
+            $this->notifications->sendWelcome($user);
+
+            return $user;
+        });
+    }
+
+    public function updateProfile(User $user, array $data): User
+    {
+        $user->update($data);
+
+        if (isset($data['avatar'])) {
+            $user->profile()->updateOrCreate(
+                ['user_id' => $user->id],
+                ['avatar' => $data['avatar']]
+            );
+        }
+
+        return $user->fresh(['profile']);
+    }
+}
+\`\`\`
+
+## Migrations
+\`\`\`php
+<?php
+
+use Illuminate\\Database\\Migrations\\Migration;
+use Illuminate\\Database\\Schema\\Blueprint;
+use Illuminate\\Support\\Facades\\Schema;
+
+return new class extends Migration
+{
+    public function up(): void
+    {
+        Schema::create('users', function (Blueprint $table) {
+            $table->uuid('id')->primary();
+            $table->string('email')->unique();
+            $table->string('name', 100);
+            $table->string('password');
+            $table->boolean('is_active')->default(true);
+            $table->timestamp('email_verified_at')->nullable();
+            $table->timestamps();
+            $table->softDeletes();
+
+            $table->index(['is_active', 'created_at']);
+        });
+    }
+
+    public function down(): void
+    {
+        Schema::dropIfExists('users');
+    }
+};
+\`\`\`
+
+## Testing
+\`\`\`php
+<?php
+
+namespace Tests\\Feature;
+
+use App\\Models\\User;
+use Illuminate\\Foundation\\Testing\\RefreshDatabase;
+use Tests\\TestCase;
+
+final class UserControllerTest extends TestCase
+{
+    use RefreshDatabase;
+
+    public function test_can_list_users(): void
+    {
+        User::factory()->count(3)->create();
+
+        $response = $this->getJson('/api/v1/users');
+
+        $response->assertOk()
+            ->assertJsonCount(3, 'data')
+            ->assertJsonStructure([
+                'data' => [['id', 'email', 'name']],
+                'meta' => ['current_page', 'total'],
+            ]);
+    }
+
+    public function test_can_create_user(): void
+    {
+        $data = [
+            'email' => 'test@example.com',
+            'name' => 'Test User',
+            'password' => 'password123',
+            'password_confirmation' => 'password123',
+        ];
+
+        $response = $this->postJson('/api/v1/users', $data);
+
+        $response->assertCreated()
+            ->assertJsonPath('data.email', 'test@example.com');
+
+        $this->assertDatabaseHas('users', [
+            'email' => 'test@example.com',
+        ]);
+    }
+
+    public function test_cannot_create_user_with_duplicate_email(): void
+    {
+        User::factory()->create(['email' => 'test@example.com']);
+
+        $response = $this->postJson('/api/v1/users', [
+            'email' => 'test@example.com',
+            'name' => 'Test',
+            'password' => 'password123',
+            'password_confirmation' => 'password123',
+        ]);
+
+        $response->assertUnprocessable()
+            ->assertJsonValidationErrors(['email']);
+    }
+}
+\`\`\`
+
+## ✅ DO
+- Use Form Requests for validation
+- Use API Resources for response transformation
+- Use Eloquent scopes for reusable queries
+- Use Service classes for complex business logic
+- Use DB::transaction for multi-model operations
+- Use \`$casts\` for type casting
+
+## ❌ DON'T
+- Don't put business logic in controllers
+- Don't return Eloquent models directly (use Resources)
+- Don't use \`DB::raw()\` without parameterized queries
+- Don't eager load everything (use \`whenLoaded\`)
+- Don't forget \`$fillable\` or \`$guarded\`

package/.claude/skills/mcp-browser.md

@@ -0,0 +1,320 @@
+# MCP Browser Skill
+
+## Server Configuration (Puppeteer)
+\`\`\`json
+// claude_desktop_config.json or .claude/settings.json
+{
+  "mcpServers": {
+    "puppeteer": {
+      "command": "npx",
+      "args": ["-y", "@modelcontextprotocol/server-puppeteer"]
+    }
+  }
+}
+\`\`\`
+
+## Server Configuration (Playwright)
+\`\`\`json
+{
+  "mcpServers": {
+    "playwright": {
+      "command": "npx",
+      "args": ["-y", "@playwright/mcp-server"],
+      "env": {
+        "BROWSER": "chromium"
+      }
+    }
+  }
+}
+\`\`\`
+
+## Available Tools
+
+### Navigation
+\`\`\`
+navigate
+- url: string (URL to navigate to)
+- Returns: page title, URL after navigation
+
+go_back
+- Returns: previous page info
+
+go_forward
+- Returns: next page info
+
+reload
+- Returns: page info after reload
+\`\`\`
+
+### Screenshot & Content
+\`\`\`
+screenshot
+- name?: string (optional filename)
+- selector?: string (capture specific element)
+- fullPage?: boolean (capture entire scrollable page)
+- Returns: base64 encoded image
+
+get_page_content
+- Returns: page HTML content
+
+get_page_text
+- Returns: visible text content
+
+get_page_title
+- Returns: page title
+
+get_current_url
+- Returns: current URL
+\`\`\`
+
+### Element Interaction
+\`\`\`
+click
+- selector: string (CSS selector or XPath)
+- button?: 'left' | 'right' | 'middle'
+- clickCount?: number (for double-click: 2)
+- Returns: success status
+
+fill
+- selector: string (input selector)
+- value: string (text to fill)
+- Returns: success status
+
+select
+- selector: string (select element)
+- value: string (option value)
+- Returns: selected value
+
+check
+- selector: string (checkbox/radio)
+- Returns: success status
+
+uncheck
+- selector: string
+- Returns: success status
+
+hover
+- selector: string
+- Returns: success status
+
+focus
+- selector: string
+- Returns: success status
+
+press
+- key: string (e.g., 'Enter', 'Tab', 'Escape')
+- Returns: success status
+
+type
+- text: string (type character by character)
+- delay?: number (ms between keystrokes)
+- Returns: success status
+\`\`\`
+
+### Element Queries
+\`\`\`
+query_selector
+- selector: string
+- Returns: element info or null
+
+query_selector_all
+- selector: string
+- Returns: array of element info
+
+get_element_text
+- selector: string
+- Returns: text content
+
+get_element_attribute
+- selector: string
+- attribute: string
+- Returns: attribute value
+
+is_visible
+- selector: string
+- Returns: boolean
+
+wait_for_selector
+- selector: string
+- timeout?: number (ms)
+- state?: 'attached' | 'detached' | 'visible' | 'hidden'
+- Returns: success status
+\`\`\`
+
+### Page Control
+\`\`\`
+scroll
+- direction: 'up' | 'down' | 'left' | 'right'
+- amount?: number (pixels)
+
+scroll_to_element
+- selector: string
+
+evaluate
+- script: string (JavaScript to execute)
+- Returns: script result
+
+wait_for_navigation
+- timeout?: number (ms)
+- Returns: new page info
+
+set_viewport
+- width: number
+- height: number
+- deviceScaleFactor?: number
+- isMobile?: boolean
+\`\`\`
+
+## Selector Strategies
+
+### CSS Selectors
+\`\`\`css
+/* By ID */
+#submit-button
+
+/* By class */
+.nav-item
+.btn.btn-primary
+
+/* By attribute */
+[data-testid="login-form"]
+input[type="email"]
+a[href^="https://"]
+
+/* By hierarchy */
+form.login input[type="password"]
+.sidebar > .menu-item:first-child
+
+/* By state (CSS pseudo-classes) */
+button:not(:disabled)
+input:focus
+\`\`\`
+
+### XPath Selectors
+\`\`\`xpath
+// By text content
+//button[text()="Submit"]
+//a[contains(text(), "Learn more")]
+
+// By attribute
+//input[@placeholder="Enter email"]
+//*[@data-testid="user-profile"]
+
+// By position
+//ul/li[1]
+(//button[@type="submit"])[2]
+
+// By parent/sibling
+//label[text()="Email"]/following-sibling::input
+//td[text()="John"]/parent::tr
+\`\`\`
+
+### Playwright-specific Selectors
+\`\`\`
+// Text selector
+text=Sign In
+text="Exact Match"
+
+// Role selector (accessibility)
+role=button[name="Submit"]
+role=link[name=/learn more/i]
+
+// Locator chaining
+.form >> input[type="email"]
+\`\`\`
+
+## Common Workflows
+
+### Form Submission
+\`\`\`
+1. navigate to form URL
+2. wait_for_selector: form element
+3. fill: email field
+4. fill: password field
+5. click: submit button
+6. wait_for_navigation
+7. screenshot: confirmation page
+\`\`\`
+
+### Data Extraction
+\`\`\`
+1. navigate to page
+2. wait_for_selector: data container
+3. query_selector_all: data items
+4. Loop: get_element_text for each
+5. Return structured data
+\`\`\`
+
+### Screenshot Testing
+\`\`\`
+1. navigate to page
+2. set_viewport: specific dimensions
+3. wait_for_selector: key content
+4. screenshot: fullPage true
+5. Compare with baseline
+\`\`\`
+
+### Authentication Flow
+\`\`\`
+1. navigate: login page
+2. fill: credentials
+3. click: sign in
+4. wait_for_selector: dashboard element
+5. Cookies persist for session
+\`\`\`
+
+## Wait Strategies
+\`\`\`javascript
+// Wait for element to appear
+wait_for_selector with state: 'visible'
+
+// Wait for element to disappear (loading spinner)
+wait_for_selector with state: 'hidden'
+
+// Wait for navigation after click
+click then wait_for_navigation
+
+// Wait for network idle (all requests complete)
+// Some servers support: wait_for_load_state('networkidle')
+
+// Fixed delay (avoid when possible)
+// Use wait_for_selector instead
+\`\`\`
+
+## Handling Dynamic Content
+\`\`\`
+// Infinite scroll
+1. scroll: down
+2. wait_for_selector: new content
+3. Repeat until done
+
+// Modal/popup
+1. click: trigger button
+2. wait_for_selector: modal container
+3. Interact with modal content
+4. click: close button
+5. wait_for_selector with state: 'hidden'
+
+// AJAX content
+1. click: trigger
+2. wait_for_selector: loading indicator (hidden)
+3. wait_for_selector: new content (visible)
+\`\`\`
+
+## ❌ DON'T
+- Use fixed delays instead of wait_for_selector
+- Click on invisible/disabled elements
+- Ignore CAPTCHA or bot protection
+- Scrape sites that prohibit it in robots.txt
+- Store credentials in automation scripts
+- Use automation for malicious purposes
+
+## ✅ DO
+- Use data-testid attributes for reliable selectors
+- Wait for elements before interacting
+- Handle navigation and loading states
+- Use appropriate viewport for responsive sites
+- Take screenshots for debugging failures
+- Respect rate limits and robots.txt
+- Handle popups and cookie banners
+- Use role selectors for accessibility