autoworkflow 3.1.4 → 3.5.0

package/.claude/skills/sveltekit.md

@@ -0,0 +1,207 @@
+# SvelteKit Skill
+
+## File Conventions
+\`\`\`
+src/
+├── routes/
+│   ├── +page.svelte           # Home page
+│   ├── +page.server.ts        # Server load/actions
+│   ├── +layout.svelte         # Root layout
+│   ├── +layout.server.ts      # Layout load function
+│   ├── +error.svelte          # Error page
+│   ├── users/
+│   │   ├── +page.svelte       # /users
+│   │   └── [id]/
+│   │       ├── +page.svelte   # /users/:id
+│   │       └── +page.server.ts
+│   └── api/
+│       └── users/+server.ts   # API endpoint
+├── lib/                        # $lib alias
+├── hooks.server.ts             # Server hooks
+└── app.html                    # HTML template
+\`\`\`
+
+## Data Loading
+\`\`\`typescript
+// +page.server.ts
+import type { PageServerLoad } from './$types';
+
+export const load: PageServerLoad = async ({ params, locals, fetch }) => {
+  // Access authenticated user from hooks
+  if (!locals.user) {
+    throw redirect(303, '/login');
+  }
+
+  const user = await db.user.findUnique({ where: { id: params.id } });
+
+  if (!user) {
+    throw error(404, 'User not found');
+  }
+
+  return { user };
+};
+
+// +page.svelte
+<script lang="ts">
+  import type { PageData } from './$types';
+  export let data: PageData;
+</script>
+
+<h1>{data.user.name}</h1>
+\`\`\`
+
+## Form Actions
+\`\`\`typescript
+// +page.server.ts
+import type { Actions } from './$types';
+import { fail, redirect } from '@sveltejs/kit';
+
+export const actions: Actions = {
+  // Default action (POST to current page)
+  default: async ({ request, locals }) => {
+    const formData = await request.formData();
+    const email = formData.get('email') as string;
+    const password = formData.get('password') as string;
+
+    // Validation
+    if (!email || !password) {
+      return fail(400, { email, missing: true });
+    }
+
+    try {
+      const user = await login(email, password);
+      locals.user = user;
+    } catch (e) {
+      return fail(401, { email, incorrect: true });
+    }
+
+    throw redirect(303, '/dashboard');
+  },
+
+  // Named action
+  logout: async ({ cookies }) => {
+    cookies.delete('session', { path: '/' });
+    throw redirect(303, '/');
+  }
+};
+
+// +page.svelte
+<script>
+  import { enhance } from '$app/forms';
+  export let form; // Action return data
+</script>
+
+<form method="POST" use:enhance>
+  <input name="email" value={form?.email ?? ''} />
+  {#if form?.missing}
+    <p class="error">Email and password required</p>
+  {/if}
+  {#if form?.incorrect}
+    <p class="error">Invalid credentials</p>
+  {/if}
+  <input type="password" name="password" />
+  <button>Login</button>
+</form>
+
+<form method="POST" action="?/logout" use:enhance>
+  <button>Logout</button>
+</form>
+\`\`\`
+
+## API Endpoints
+\`\`\`typescript
+// routes/api/users/+server.ts
+import { json, error } from '@sveltejs/kit';
+import type { RequestHandler } from './$types';
+
+export const GET: RequestHandler = async ({ url }) => {
+  const limit = Number(url.searchParams.get('limit') ?? 10);
+  const users = await db.user.findMany({ take: limit });
+  return json(users);
+};
+
+export const POST: RequestHandler = async ({ request }) => {
+  const data = await request.json();
+
+  if (!data.email) {
+    throw error(400, 'Email required');
+  }
+
+  const user = await db.user.create({ data });
+  return json(user, { status: 201 });
+};
+\`\`\`
+
+## Hooks
+\`\`\`typescript
+// src/hooks.server.ts
+import type { Handle, HandleServerError } from '@sveltejs/kit';
+
+export const handle: Handle = async ({ event, resolve }) => {
+  // Run on every request
+  const session = event.cookies.get('session');
+
+  if (session) {
+    event.locals.user = await getUserFromSession(session);
+  }
+
+  // Add custom headers
+  const response = await resolve(event);
+  response.headers.set('X-Custom-Header', 'value');
+
+  return response;
+};
+
+export const handleError: HandleServerError = async ({ error, event }) => {
+  // Log errors
+  console.error(error);
+
+  return {
+    message: 'An unexpected error occurred',
+    code: 'INTERNAL_ERROR'
+  };
+};
+\`\`\`
+
+## Page Options
+\`\`\`typescript
+// +page.ts or +page.server.ts
+export const prerender = true;  // Static generation
+export const ssr = false;       // Client-only
+export const csr = true;        // Enable client-side JS
+
+// +layout.server.ts
+export const trailingSlash = 'always'; // URL formatting
+\`\`\`
+
+## Authentication Pattern
+\`\`\`typescript
+// src/hooks.server.ts
+export const handle: Handle = async ({ event, resolve }) => {
+  const session = event.cookies.get('session');
+  event.locals.user = session ? await validateSession(session) : null;
+  return resolve(event);
+};
+
+// src/routes/(protected)/+layout.server.ts
+export const load = async ({ locals }) => {
+  if (!locals.user) {
+    throw redirect(303, '/login');
+  }
+  return { user: locals.user };
+};
+\`\`\`
+
+## ❌ DON'T
+- Use fetch in load functions for internal APIs (use db directly)
+- Forget to handle form validation errors
+- Skip type safety with $types
+- Put secrets in +page.ts (client-accessible)
+
+## ✅ DO
+- Use load functions for data fetching
+- Use form actions for mutations
+- Use hooks for authentication
+- Use +page.server.ts for sensitive operations
+- Enable prerendering for static pages
+- Use use:enhance for progressive enhancement

package/.claude/skills/symfony.md

@@ -0,0 +1,437 @@
+# Symfony Skill
+
+## Controller
+\`\`\`php
+<?php
+
+namespace App\\Controller\\Api\\V1;
+
+use App\\DTO\\CreateUserRequest;
+use App\\DTO\\UpdateUserRequest;
+use App\\Entity\\User;
+use App\\Repository\\UserRepository;
+use App\\Service\\UserService;
+use Symfony\\Bundle\\FrameworkBundle\\Controller\\AbstractController;
+use Symfony\\Component\\HttpFoundation\\JsonResponse;
+use Symfony\\Component\\HttpFoundation\\Response;
+use Symfony\\Component\\HttpKernel\\Attribute\\MapRequestPayload;
+use Symfony\\Component\\Routing\\Attribute\\Route;
+
+#[Route('/api/v1/users')]
+final class UserController extends AbstractController
+{
+    public function __construct(
+        private readonly UserService $userService,
+        private readonly UserRepository $repository,
+    ) {}
+
+    #[Route('', methods: ['GET'])]
+    public function index(): JsonResponse
+    {
+        $users = $this->repository->findAllActive();
+        return $this->json($users, context: ['groups' => ['user:list']]);
+    }
+
+    #[Route('/{id}', methods: ['GET'])]
+    public function show(User $user): JsonResponse
+    {
+        return $this->json($user, context: ['groups' => ['user:read']]);
+    }
+
+    #[Route('', methods: ['POST'])]
+    public function create(
+        #[MapRequestPayload] CreateUserRequest $request
+    ): JsonResponse {
+        $user = $this->userService->create($request);
+
+        return $this->json(
+            $user,
+            Response::HTTP_CREATED,
+            context: ['groups' => ['user:read']]
+        );
+    }
+
+    #[Route('/{id}', methods: ['PUT'])]
+    public function update(
+        User $user,
+        #[MapRequestPayload] UpdateUserRequest $request
+    ): JsonResponse {
+        $user = $this->userService->update($user, $request);
+
+        return $this->json($user, context: ['groups' => ['user:read']]);
+    }
+
+    #[Route('/{id}', methods: ['DELETE'])]
+    public function delete(User $user): Response
+    {
+        $this->userService->delete($user);
+
+        return new Response(null, Response::HTTP_NO_CONTENT);
+    }
+}
+\`\`\`
+
+## DTO with Validation
+\`\`\`php
+<?php
+
+namespace App\\DTO;
+
+use Symfony\\Component\\Validator\\Constraints as Assert;
+
+final readonly class CreateUserRequest
+{
+    public function __construct(
+        #[Assert\\NotBlank]
+        #[Assert\\Email]
+        #[Assert\\Length(max: 255)]
+        public string $email,
+
+        #[Assert\\NotBlank]
+        #[Assert\\Length(min: 2, max: 100)]
+        public string $name,
+
+        #[Assert\\NotBlank]
+        #[Assert\\Length(min: 8)]
+        #[Assert\\PasswordStrength]
+        public string $password,
+    ) {}
+}
+
+final readonly class UpdateUserRequest
+{
+    public function __construct(
+        #[Assert\\Length(min: 2, max: 100)]
+        public ?string $name = null,
+
+        #[Assert\\Email]
+        public ?string $email = null,
+    ) {}
+}
+\`\`\`
+
+## Service
+\`\`\`php
+<?php
+
+namespace App\\Service;
+
+use App\\DTO\\CreateUserRequest;
+use App\\DTO\\UpdateUserRequest;
+use App\\Entity\\User;
+use App\\Repository\\UserRepository;
+use Doctrine\\ORM\\EntityManagerInterface;
+use Symfony\\Component\\PasswordHasher\\Hasher\\UserPasswordHasherInterface;
+
+final readonly class UserService
+{
+    public function __construct(
+        private EntityManagerInterface $em,
+        private UserRepository $repository,
+        private UserPasswordHasherInterface $hasher,
+    ) {}
+
+    public function create(CreateUserRequest $request): User
+    {
+        $user = new User();
+        $user->setEmail($request->email);
+        $user->setName($request->name);
+        $user->setPassword($this->hasher->hashPassword($user, $request->password));
+
+        $this->em->persist($user);
+        $this->em->flush();
+
+        return $user;
+    }
+
+    public function update(User $user, UpdateUserRequest $request): User
+    {
+        if ($request->name !== null) {
+            $user->setName($request->name);
+        }
+        if ($request->email !== null) {
+            $user->setEmail($request->email);
+        }
+
+        $this->em->flush();
+
+        return $user;
+    }
+
+    public function delete(User $user): void
+    {
+        $this->em->remove($user);
+        $this->em->flush();
+    }
+}
+\`\`\`
+
+## Repository
+\`\`\`php
+<?php
+
+namespace App\\Repository;
+
+use App\\Entity\\User;
+use Doctrine\\Bundle\\DoctrineBundle\\Repository\\ServiceEntityRepository;
+use Doctrine\\Persistence\\ManagerRegistry;
+
+/**
+ * @extends ServiceEntityRepository<User>
+ */
+final class UserRepository extends ServiceEntityRepository
+{
+    public function __construct(ManagerRegistry $registry)
+    {
+        parent::__construct($registry, User::class);
+    }
+
+    public function findByEmail(string $email): ?User
+    {
+        return $this->findOneBy(['email' => $email]);
+    }
+
+    /**
+     * @return User[]
+     */
+    public function findAllActive(): array
+    {
+        return $this->createQueryBuilder('u')
+            ->where('u.isActive = :active')
+            ->setParameter('active', true)
+            ->orderBy('u.createdAt', 'DESC')
+            ->getQuery()
+            ->getResult();
+    }
+
+    /**
+     * @return User[]
+     */
+    public function findPaginated(int $page, int $limit): array
+    {
+        return $this->createQueryBuilder('u')
+            ->setFirstResult(($page - 1) * $limit)
+            ->setMaxResults($limit)
+            ->orderBy('u.createdAt', 'DESC')
+            ->getQuery()
+            ->getResult();
+    }
+
+    public function countActive(): int
+    {
+        return $this->createQueryBuilder('u')
+            ->select('COUNT(u.id)')
+            ->where('u.isActive = :active')
+            ->setParameter('active', true)
+            ->getQuery()
+            ->getSingleScalarResult();
+    }
+}
+\`\`\`
+
+## Exception Handler
+\`\`\`php
+<?php
+
+namespace App\\EventListener;
+
+use App\\Exception\\NotFoundException;
+use App\\Exception\\ValidationException;
+use Symfony\\Component\\HttpFoundation\\JsonResponse;
+use Symfony\\Component\\HttpFoundation\\Response;
+use Symfony\\Component\\HttpKernel\\Event\\ExceptionEvent;
+use Symfony\\Component\\HttpKernel\\Exception\\HttpExceptionInterface;
+
+final class ExceptionListener
+{
+    public function onKernelException(ExceptionEvent $event): void
+    {
+        $exception = $event->getThrowable();
+
+        $response = match (true) {
+            $exception instanceof NotFoundException => new JsonResponse(
+                ['error' => $exception->getMessage()],
+                Response::HTTP_NOT_FOUND
+            ),
+            $exception instanceof ValidationException => new JsonResponse(
+                ['error' => 'Validation failed', 'errors' => $exception->getErrors()],
+                Response::HTTP_BAD_REQUEST
+            ),
+            $exception instanceof HttpExceptionInterface => new JsonResponse(
+                ['error' => $exception->getMessage()],
+                $exception->getStatusCode()
+            ),
+            default => new JsonResponse(
+                ['error' => 'Internal server error'],
+                Response::HTTP_INTERNAL_SERVER_ERROR
+            ),
+        };
+
+        $event->setResponse($response);
+    }
+}
+\`\`\`
+
+## Events
+\`\`\`php
+<?php
+
+namespace App\\Event;
+
+final readonly class UserCreatedEvent
+{
+    public function __construct(
+        public string $userId,
+        public string $email,
+    ) {}
+}
+
+// Listener
+namespace App\\EventListener;
+
+use App\\Event\\UserCreatedEvent;
+use Symfony\\Component\\EventDispatcher\\Attribute\\AsEventListener;
+
+#[AsEventListener]
+final readonly class SendWelcomeEmailListener
+{
+    public function __construct(
+        private MailerInterface $mailer,
+    ) {}
+
+    public function __invoke(UserCreatedEvent $event): void
+    {
+        // Send welcome email
+    }
+}
+
+// Dispatch in service
+$this->eventDispatcher->dispatch(new UserCreatedEvent($user->getId(), $user->getEmail()));
+\`\`\`
+
+## Security
+\`\`\`php
+<?php
+
+// Entity implementing UserInterface
+namespace App\\Entity;
+
+use Symfony\\Component\\Security\\Core\\User\\PasswordAuthenticatedUserInterface;
+use Symfony\\Component\\Security\\Core\\User\\UserInterface;
+
+class User implements UserInterface, PasswordAuthenticatedUserInterface
+{
+    public function getRoles(): array
+    {
+        $roles = $this->roles;
+        $roles[] = 'ROLE_USER';
+        return array_unique($roles);
+    }
+
+    public function getUserIdentifier(): string
+    {
+        return $this->email;
+    }
+
+    public function getPassword(): string
+    {
+        return $this->password;
+    }
+
+    public function eraseCredentials(): void
+    {
+        // Clear any temporary sensitive data
+    }
+}
+
+// Controller with authorization
+#[Route('/api/v1/admin/users')]
+#[IsGranted('ROLE_ADMIN')]
+final class AdminUserController extends AbstractController
+{
+    #[Route('/{id}', methods: ['DELETE'])]
+    #[IsGranted('ROLE_SUPER_ADMIN')]
+    public function delete(User $user): Response
+    {
+        // ...
+    }
+}
+\`\`\`
+
+## Testing
+\`\`\`php
+<?php
+
+namespace App\\Tests\\Controller;
+
+use App\\Entity\\User;
+use Doctrine\\ORM\\EntityManagerInterface;
+use Symfony\\Bundle\\FrameworkBundle\\Test\\WebTestCase;
+
+final class UserControllerTest extends WebTestCase
+{
+    private EntityManagerInterface $em;
+
+    protected function setUp(): void
+    {
+        $this->em = self::getContainer()->get(EntityManagerInterface::class);
+    }
+
+    public function testListUsers(): void
+    {
+        $client = static::createClient();
+
+        $client->request('GET', '/api/v1/users');
+
+        $this->assertResponseIsSuccessful();
+        $this->assertResponseHeaderSame('content-type', 'application/json');
+    }
+
+    public function testCreateUser(): void
+    {
+        $client = static::createClient();
+
+        $client->request('POST', '/api/v1/users', [], [], [
+            'CONTENT_TYPE' => 'application/json',
+        ], json_encode([
+            'email' => 'test@example.com',
+            'name' => 'Test User',
+            'password' => 'Password123!',
+        ]));
+
+        $this->assertResponseStatusCodeSame(201);
+
+        $user = $this->em->getRepository(User::class)->findByEmail('test@example.com');
+        $this->assertNotNull($user);
+    }
+
+    public function testCreateUserValidationError(): void
+    {
+        $client = static::createClient();
+
+        $client->request('POST', '/api/v1/users', [], [], [
+            'CONTENT_TYPE' => 'application/json',
+        ], json_encode([
+            'email' => 'invalid',
+            'name' => '',
+            'password' => '123',
+        ]));
+
+        $this->assertResponseStatusCodeSame(422);
+    }
+}
+\`\`\`
+
+## ✅ DO
+- Use constructor property promotion
+- Use attributes for routing and validation
+- Use \`#[MapRequestPayload]\` for automatic DTO mapping
+- Use services for business logic
+- Use events for side effects
+- Use serialization groups for API responses
+
+## ❌ DON'T
+- Don't inject EntityManager in controllers (use services)
+- Don't put business logic in controllers
+- Don't return entities directly (use serialization groups or DTOs)
+- Don't catch exceptions in controllers (use event listeners)