autoworkflow 3.1.5 → 3.5.0

package/.claude/skills/quarkus.md

@@ -0,0 +1,377 @@
+# Quarkus Skill
+
+## Project Setup
+\`\`\`bash
+# Create new project
+quarkus create app com.example:myapp \\
+  --extension='resteasy-reactive-jackson,hibernate-orm-panache,jdbc-postgresql,smallrye-jwt'
+
+# Run in dev mode (hot reload)
+quarkus dev
+
+# Build native executable
+quarkus build --native
+\`\`\`
+
+## REST Resource with JAX-RS
+\`\`\`java
+@Path("/api/v1/users")
+@Produces(MediaType.APPLICATION_JSON)
+@Consumes(MediaType.APPLICATION_JSON)
+public class UserResource {
+
+    @Inject
+    UserService userService;
+
+    @GET
+    public List<UserResponse> listUsers(
+            @QueryParam("page") @DefaultValue("0") int page,
+            @QueryParam("size") @DefaultValue("20") int size) {
+        return userService.findAll(page, size);
+    }
+
+    @GET
+    @Path("/{id}")
+    public UserResponse getUser(@PathParam("id") String id) {
+        return userService.findById(id)
+            .orElseThrow(() -> new NotFoundException("User not found: " + id));
+    }
+
+    @POST
+    public Response createUser(@Valid CreateUserRequest request) {
+        UserResponse user = userService.create(request);
+        return Response.status(Response.Status.CREATED)
+            .entity(user)
+            .location(URI.create("/api/v1/users/" + user.id()))
+            .build();
+    }
+
+    @PUT
+    @Path("/{id}")
+    public UserResponse updateUser(
+            @PathParam("id") String id,
+            @Valid UpdateUserRequest request) {
+        return userService.update(id, request);
+    }
+
+    @DELETE
+    @Path("/{id}")
+    public Response deleteUser(@PathParam("id") String id) {
+        userService.delete(id);
+        return Response.noContent().build();
+    }
+}
+\`\`\`
+
+## Reactive REST Resource
+\`\`\`java
+@Path("/api/v1/users")
+@Produces(MediaType.APPLICATION_JSON)
+@Consumes(MediaType.APPLICATION_JSON)
+public class UserResource {
+
+    @Inject
+    UserService userService;
+
+    @GET
+    public Uni<List<UserResponse>> listUsers() {
+        return userService.findAllAsync();
+    }
+
+    @GET
+    @Path("/{id}")
+    public Uni<UserResponse> getUser(@PathParam("id") String id) {
+        return userService.findByIdAsync(id)
+            .onItem().ifNull().failWith(() -> new NotFoundException("User not found"));
+    }
+
+    @POST
+    public Uni<Response> createUser(@Valid CreateUserRequest request) {
+        return userService.createAsync(request)
+            .onItem().transform(user -> Response.status(Response.Status.CREATED)
+                .entity(user)
+                .build());
+    }
+}
+\`\`\`
+
+## Panache Entity (Active Record Pattern)
+\`\`\`java
+@Entity
+@Table(name = "users")
+public class User extends PanacheEntityBase {
+
+    @Id
+    @GeneratedValue(strategy = GenerationType.UUID)
+    public String id;
+
+    @Column(unique = true, nullable = false)
+    public String email;
+
+    @Column(nullable = false)
+    public String name;
+
+    @Column(name = "password_hash", nullable = false)
+    public String passwordHash;
+
+    @Column(name = "is_active")
+    public boolean isActive = true;
+
+    @Column(name = "created_at")
+    public Instant createdAt;
+
+    // Static finder methods
+    public static Optional<User> findByEmail(String email) {
+        return find("email", email).firstResultOptional();
+    }
+
+    public static List<User> findActive() {
+        return list("isActive", true);
+    }
+
+    public static PanacheQuery<User> findActiveQuery() {
+        return find("isActive", Sort.by("createdAt").descending(), true);
+    }
+
+    // Lifecycle callbacks
+    @PrePersist
+    void onCreate() {
+        createdAt = Instant.now();
+    }
+}
+
+// Usage
+User user = new User();
+user.email = "test@example.com";
+user.name = "Test";
+user.persist();
+
+Optional<User> found = User.findByEmail("test@example.com");
+List<User> page = User.findActiveQuery().page(0, 20).list();
+long count = User.count("isActive", true);
+\`\`\`
+
+## Panache Repository Pattern
+\`\`\`java
+@ApplicationScoped
+public class UserRepository implements PanacheRepositoryBase<User, String> {
+
+    public Optional<User> findByEmail(String email) {
+        return find("email", email).firstResultOptional();
+    }
+
+    public List<User> findActive(int page, int size) {
+        return find("isActive", Sort.by("createdAt").descending(), true)
+            .page(page, size)
+            .list();
+    }
+
+    public long countActive() {
+        return count("isActive", true);
+    }
+}
+
+// Reactive repository
+@ApplicationScoped
+public class UserRepository implements PanacheRepositoryBase<User, String> {
+
+    public Uni<Optional<User>> findByEmailAsync(String email) {
+        return find("email", email).firstResultOptional();
+    }
+
+    public Uni<List<User>> findActiveAsync() {
+        return find("isActive", true).list();
+    }
+}
+\`\`\`
+
+## Service with CDI
+\`\`\`java
+@ApplicationScoped
+public class UserService {
+
+    @Inject
+    UserRepository userRepository;
+
+    @Inject
+    PasswordEncoder passwordEncoder;
+
+    public List<UserResponse> findAll(int page, int size) {
+        return userRepository.findActive(page, size)
+            .stream()
+            .map(UserResponse::from)
+            .toList();
+    }
+
+    public Optional<UserResponse> findById(String id) {
+        return userRepository.findByIdOptional(id)
+            .map(UserResponse::from);
+    }
+
+    @Transactional
+    public UserResponse create(CreateUserRequest request) {
+        if (userRepository.findByEmail(request.email()).isPresent()) {
+            throw new ConflictException("Email already exists");
+        }
+
+        User user = new User();
+        user.email = request.email();
+        user.name = request.name();
+        user.passwordHash = passwordEncoder.encode(request.password());
+        userRepository.persist(user);
+
+        return UserResponse.from(user);
+    }
+
+    @Transactional
+    public UserResponse update(String id, UpdateUserRequest request) {
+        User user = userRepository.findByIdOptional(id)
+            .orElseThrow(() -> new NotFoundException("User not found"));
+
+        if (request.name() != null) {
+            user.name = request.name();
+        }
+
+        return UserResponse.from(user);
+    }
+
+    @Transactional
+    public void delete(String id) {
+        if (!userRepository.deleteById(id)) {
+            throw new NotFoundException("User not found");
+        }
+    }
+}
+\`\`\`
+
+## Exception Handling
+\`\`\`java
+@Provider
+public class ExceptionMappers {
+
+    @ServerExceptionMapper
+    public Response handleNotFound(NotFoundException e) {
+        return Response.status(Response.Status.NOT_FOUND)
+            .entity(new ErrorResponse("NOT_FOUND", e.getMessage()))
+            .build();
+    }
+
+    @ServerExceptionMapper
+    public Response handleConflict(ConflictException e) {
+        return Response.status(Response.Status.CONFLICT)
+            .entity(new ErrorResponse("CONFLICT", e.getMessage()))
+            .build();
+    }
+
+    @ServerExceptionMapper
+    public Response handleValidation(ConstraintViolationException e) {
+        Map<String, String> errors = e.getConstraintViolations().stream()
+            .collect(Collectors.toMap(
+                v -> v.getPropertyPath().toString(),
+                ConstraintViolation::getMessage
+            ));
+        return Response.status(Response.Status.BAD_REQUEST)
+            .entity(new ValidationErrorResponse("VALIDATION_ERROR", errors))
+            .build();
+    }
+}
+
+public record ErrorResponse(String code, String message) {}
+public record ValidationErrorResponse(String code, Map<String, String> errors) {}
+\`\`\`
+
+## Configuration
+\`\`\`properties
+# application.properties
+
+# Database
+quarkus.datasource.db-kind=postgresql
+quarkus.datasource.jdbc.url=\${DATABASE_URL}
+quarkus.datasource.username=\${DATABASE_USER}
+quarkus.datasource.password=\${DATABASE_PASSWORD}
+
+# Hibernate
+quarkus.hibernate-orm.database.generation=validate
+
+# JWT Security
+mp.jwt.verify.publickey.location=publicKey.pem
+mp.jwt.verify.issuer=https://example.com
+
+# Native build optimizations
+quarkus.native.additional-build-args=--initialize-at-run-time=org.example.MyClass
+\`\`\`
+
+## Testing
+\`\`\`java
+@QuarkusTest
+class UserResourceTest {
+
+    @Test
+    void testGetUser() {
+        given()
+            .when().get("/api/v1/users/1")
+            .then()
+            .statusCode(200)
+            .body("email", equalTo("test@example.com"));
+    }
+
+    @Test
+    void testCreateUser() {
+        given()
+            .contentType(MediaType.APPLICATION_JSON)
+            .body("""
+                {"email": "new@example.com", "name": "New User", "password": "password123"}
+                """)
+            .when().post("/api/v1/users")
+            .then()
+            .statusCode(201)
+            .header("Location", containsString("/api/v1/users/"));
+    }
+
+    @Test
+    void testCreateUserInvalidEmail() {
+        given()
+            .contentType(MediaType.APPLICATION_JSON)
+            .body("""
+                {"email": "invalid", "name": "Test", "password": "password123"}
+                """)
+            .when().post("/api/v1/users")
+            .then()
+            .statusCode(400);
+    }
+}
+
+@QuarkusTest
+@TestProfile(TestProfile.class)  // Use test configuration
+class UserServiceTest {
+
+    @Inject
+    UserService userService;
+
+    @Test
+    @Transactional
+    void testCreateAndFind() {
+        var request = new CreateUserRequest("test@example.com", "Test", "password123");
+        var created = userService.create(request);
+
+        assertThat(created.email()).isEqualTo("test@example.com");
+
+        var found = userService.findById(created.id());
+        assertThat(found).isPresent();
+    }
+}
+\`\`\`
+
+## ✅ DO
+- Use Panache for simplified data access
+- Use CDI \`@Inject\` for dependency injection
+- Use \`@Transactional\` on service methods
+- Use \`Uni<T>\` for reactive endpoints
+- Use \`@ServerExceptionMapper\` for error handling
+- Profile with \`quarkus dev\` for optimal native image
+
+## ❌ DON'T
+- Don't use constructor injection (use field injection with CDI)
+- Don't return null - use Optional or throw exceptions
+- Don't block in reactive code
+- Don't forget \`@Transactional\` for write operations with Panache

package/.claude/skills/react.md

@@ -0,0 +1,230 @@
+# React Skill
+
+## Component Structure
+\`\`\`tsx
+export function UserProfile({ userId }: Props) {
+  // 1. Hooks first
+  const [user, setUser] = useState<User | null>(null);
+  const [loading, setLoading] = useState(true);
+
+  // 2. Derived values
+  const fullName = user ? \`\${user.firstName} \${user.lastName}\` : '';
+
+  // 3. Effects
+  useEffect(() => {
+    fetchUser(userId).then(setUser).finally(() => setLoading(false));
+  }, [userId]);
+
+  // 4. Handlers
+  const handleLogout = () => { /* ... */ };
+
+  // 5. Early returns
+  if (loading) return <Skeleton />;
+  if (!user) return <NotFound />;
+
+  // 6. Main render
+  return <div>...</div>;
+}
+\`\`\`
+
+## Custom Hooks
+\`\`\`tsx
+// ✅ Extract reusable logic into custom hooks
+function useLocalStorage<T>(key: string, initialValue: T) {
+  const [value, setValue] = useState<T>(() => {
+    const stored = localStorage.getItem(key);
+    return stored ? JSON.parse(stored) : initialValue;
+  });
+
+  useEffect(() => {
+    localStorage.setItem(key, JSON.stringify(value));
+  }, [key, value]);
+
+  return [value, setValue] as const;
+}
+
+// ✅ Data fetching hook
+function useUser(userId: string) {
+  const [user, setUser] = useState<User | null>(null);
+  const [loading, setLoading] = useState(true);
+  const [error, setError] = useState<Error | null>(null);
+
+  useEffect(() => {
+    setLoading(true);
+    fetchUser(userId)
+      .then(setUser)
+      .catch(setError)
+      .finally(() => setLoading(false));
+  }, [userId]);
+
+  return { user, loading, error };
+}
+\`\`\`
+
+## Performance Optimization
+\`\`\`tsx
+// ✅ Memoize expensive computations
+const sortedItems = useMemo(
+  () => items.sort((a, b) => b.score - a.score),
+  [items]
+);
+
+// ✅ Memoize callbacks passed to children
+const handleClick = useCallback(
+  (id: string) => onSelect(id),
+  [onSelect]
+);
+
+// ✅ Memoize components receiving object/array props
+const MemoizedList = memo(function List({ items }: Props) {
+  return items.map(item => <Item key={item.id} {...item} />);
+});
+
+// ✅ Skip re-renders with proper comparison
+const MemoizedCard = memo(Card, (prev, next) => {
+  return prev.id === next.id && prev.name === next.name;
+});
+\`\`\`
+
+## Error Boundaries
+\`\`\`tsx
+class ErrorBoundary extends Component<Props, State> {
+  state = { hasError: false, error: null };
+
+  static getDerivedStateFromError(error: Error) {
+    return { hasError: true, error };
+  }
+
+  componentDidCatch(error: Error, info: ErrorInfo) {
+    logErrorToService(error, info.componentStack);
+  }
+
+  render() {
+    if (this.state.hasError) {
+      return <ErrorFallback error={this.state.error} />;
+    }
+    return this.props.children;
+  }
+}
+
+// Usage
+<ErrorBoundary fallback={<ErrorPage />}>
+  <App />
+</ErrorBoundary>
+\`\`\`
+
+## Form Handling (react-hook-form)
+\`\`\`tsx
+import { useForm } from 'react-hook-form';
+import { zodResolver } from '@hookform/resolvers/zod';
+
+const schema = z.object({
+  email: z.string().email(),
+  password: z.string().min(8),
+});
+
+function LoginForm() {
+  const { register, handleSubmit, formState: { errors } } = useForm({
+    resolver: zodResolver(schema),
+  });
+
+  const onSubmit = (data: FormData) => {
+    // data is typed and validated
+  };
+
+  return (
+    <form onSubmit={handleSubmit(onSubmit)}>
+      <input {...register('email')} />
+      {errors.email && <span>{errors.email.message}</span>}
+
+      <input type="password" {...register('password')} />
+      {errors.password && <span>{errors.password.message}</span>}
+
+      <button type="submit">Login</button>
+    </form>
+  );
+}
+\`\`\`
+
+## Context API
+\`\`\`tsx
+// ✅ Create typed context with default
+interface AuthContextType {
+  user: User | null;
+  login: (email: string, password: string) => Promise<void>;
+  logout: () => void;
+}
+
+const AuthContext = createContext<AuthContextType | null>(null);
+
+// ✅ Custom hook for consuming context
+function useAuth() {
+  const context = useContext(AuthContext);
+  if (!context) {
+    throw new Error('useAuth must be used within AuthProvider');
+  }
+  return context;
+}
+
+// ✅ Provider component
+function AuthProvider({ children }: { children: ReactNode }) {
+  const [user, setUser] = useState<User | null>(null);
+
+  const login = async (email: string, password: string) => {
+    const user = await authService.login(email, password);
+    setUser(user);
+  };
+
+  const logout = () => setUser(null);
+
+  return (
+    <AuthContext.Provider value={{ user, login, logout }}>
+      {children}
+    </AuthContext.Provider>
+  );
+}
+\`\`\`
+
+## Compound Component Pattern
+\`\`\`tsx
+// ✅ Flexible, composable API
+const Tabs = ({ children, defaultTab }) => {
+  const [activeTab, setActiveTab] = useState(defaultTab);
+  return (
+    <TabsContext.Provider value={{ activeTab, setActiveTab }}>
+      {children}
+    </TabsContext.Provider>
+  );
+};
+
+Tabs.List = ({ children }) => <div role="tablist">{children}</div>;
+Tabs.Tab = ({ id, children }) => { /* ... */ };
+Tabs.Panel = ({ id, children }) => { /* ... */ };
+
+// Usage
+<Tabs defaultTab="settings">
+  <Tabs.List>
+    <Tabs.Tab id="profile">Profile</Tabs.Tab>
+    <Tabs.Tab id="settings">Settings</Tabs.Tab>
+  </Tabs.List>
+  <Tabs.Panel id="profile"><Profile /></Tabs.Panel>
+  <Tabs.Panel id="settings"><Settings /></Tabs.Panel>
+</Tabs>
+\`\`\`
+
+## ❌ DON'T
+- Use useEffect for data fetching (use React Query/SWR)
+- Mutate state directly
+- Use index as key for dynamic lists
+- Create components inside components
+- Overuse useMemo/useCallback (measure first)
+- Put too much in Context (causes re-renders)
+
+## ✅ DO
+- Use React Query/SWR for server state
+- Use useState for UI state only
+- Memoize expensive computations: useMemo
+- Extract custom hooks for reusable logic
+- Use Error Boundaries for graceful failures
+- Use react-hook-form for complex forms
+- Split Context by update frequency