autoworkflow 3.1.4 → 3.5.0

package/.claude/skills/java.md

@@ -0,0 +1,400 @@
+# Java Skill
+
+## Records (Java 16+)
+\`\`\`java
+// Immutable data carriers
+public record User(
+    String id,
+    String email,
+    String name,
+    boolean isActive,
+    Instant createdAt
+) {
+    // Compact constructor for validation
+    public User {
+        Objects.requireNonNull(id, "id cannot be null");
+        Objects.requireNonNull(email, "email cannot be null");
+        if (!email.contains("@")) {
+            throw new IllegalArgumentException("Invalid email format");
+        }
+    }
+
+    // Additional methods
+    public String displayName() {
+        return name != null ? name : email.split("@")[0];
+    }
+}
+
+// DTOs as records
+public record CreateUserRequest(
+    @NotBlank String email,
+    @NotBlank @Size(min = 2, max = 100) String name,
+    @NotBlank @Size(min = 8) String password
+) {}
+
+public record UserResponse(
+    String id,
+    String email,
+    String name,
+    boolean isActive
+) {
+    public static UserResponse from(User user) {
+        return new UserResponse(
+            user.id(),
+            user.email(),
+            user.name(),
+            user.isActive()
+        );
+    }
+}
+
+public record PaginatedResponse<T>(
+    List<T> items,
+    long total,
+    int page,
+    int perPage
+) {
+    public int totalPages() {
+        return (int) Math.ceil((double) total / perPage);
+    }
+
+    public boolean hasNext() {
+        return page < totalPages();
+    }
+}
+\`\`\`
+
+## Optional Patterns
+\`\`\`java
+import java.util.Optional;
+
+public class UserService {
+    private final UserRepository repository;
+
+    // Return Optional for queries that may not find a result
+    public Optional<User> findById(String id) {
+        return repository.findById(id);
+    }
+
+    // Use Optional methods instead of null checks
+    public User getUser(String id) {
+        return findById(id)
+            .orElseThrow(() -> new NotFoundException("User not found: " + id));
+    }
+
+    // Chaining Optional operations
+    public Optional<String> getUserEmail(String id) {
+        return findById(id)
+            .filter(User::isActive)
+            .map(User::email);
+    }
+
+    // Optional with default value
+    public String getUserName(String id) {
+        return findById(id)
+            .map(User::name)
+            .orElse("Anonymous");
+    }
+
+    // Optional with lazy default
+    public User getOrCreate(String email) {
+        return repository.findByEmail(email)
+            .orElseGet(() -> repository.save(new User(email)));
+    }
+
+    // Avoid Optional.get() - use orElseThrow instead
+    public void processUser(String id) {
+        findById(id).ifPresentOrElse(
+            this::process,
+            () -> log.warn("User not found: {}", id)
+        );
+    }
+
+    // Flatten nested Optionals
+    public Optional<String> getProfileBio(String userId) {
+        return findById(userId)
+            .flatMap(User::profile)  // profile returns Optional<Profile>
+            .map(Profile::bio);
+    }
+}
+\`\`\`
+
+## Stream API
+\`\`\`java
+import java.util.stream.*;
+
+public class UserAnalytics {
+
+    // Filter, map, collect
+    public List<String> getActiveUserEmails(List<User> users) {
+        return users.stream()
+            .filter(User::isActive)
+            .map(User::email)
+            .sorted()
+            .toList();  // Java 16+ (or .collect(Collectors.toList()))
+    }
+
+    // Grouping
+    public Map<String, List<User>> groupByDomain(List<User> users) {
+        return users.stream()
+            .collect(Collectors.groupingBy(
+                user -> user.email().split("@")[1]
+            ));
+    }
+
+    // Counting
+    public Map<Boolean, Long> countByActiveStatus(List<User> users) {
+        return users.stream()
+            .collect(Collectors.partitioningBy(
+                User::isActive,
+                Collectors.counting()
+            ));
+    }
+
+    // Reducing
+    public int totalPostCount(List<User> users) {
+        return users.stream()
+            .mapToInt(User::postCount)
+            .sum();
+    }
+
+    // FlatMap for nested collections
+    public List<Post> getAllPosts(List<User> users) {
+        return users.stream()
+            .flatMap(user -> user.posts().stream())
+            .sorted(Comparator.comparing(Post::createdAt).reversed())
+            .toList();
+    }
+
+    // Finding elements
+    public Optional<User> findFirstAdmin(List<User> users) {
+        return users.stream()
+            .filter(u -> u.role().equals("ADMIN"))
+            .findFirst();
+    }
+
+    // Checking conditions
+    public boolean allUsersActive(List<User> users) {
+        return users.stream().allMatch(User::isActive);
+    }
+
+    public boolean anyUserAdmin(List<User> users) {
+        return users.stream().anyMatch(u -> u.role().equals("ADMIN"));
+    }
+
+    // Parallel streams (use for CPU-intensive operations on large datasets)
+    public List<UserStats> computeStats(List<User> users) {
+        return users.parallelStream()
+            .map(this::computeUserStats)
+            .toList();
+    }
+
+    // Collectors.toMap
+    public Map<String, User> userById(List<User> users) {
+        return users.stream()
+            .collect(Collectors.toMap(
+                User::id,
+                Function.identity(),
+                (existing, replacement) -> existing  // Handle duplicates
+            ));
+    }
+}
+\`\`\`
+
+## Exception Handling
+\`\`\`java
+// Custom exceptions
+public class AppException extends RuntimeException {
+    private final ErrorCode code;
+
+    public AppException(ErrorCode code, String message) {
+        super(message);
+        this.code = code;
+    }
+
+    public AppException(ErrorCode code, String message, Throwable cause) {
+        super(message, cause);
+        this.code = code;
+    }
+
+    public ErrorCode getCode() {
+        return code;
+    }
+}
+
+public class NotFoundException extends AppException {
+    public NotFoundException(String message) {
+        super(ErrorCode.NOT_FOUND, message);
+    }
+}
+
+public class ValidationException extends AppException {
+    private final Map<String, String> errors;
+
+    public ValidationException(Map<String, String> errors) {
+        super(ErrorCode.VALIDATION_ERROR, "Validation failed");
+        this.errors = errors;
+    }
+
+    public Map<String, String> getErrors() {
+        return errors;
+    }
+}
+
+// Try-with-resources
+public void processFile(Path path) {
+    try (var reader = Files.newBufferedReader(path);
+         var writer = Files.newBufferedWriter(outputPath)) {
+        // Resources automatically closed
+        reader.lines()
+            .map(this::transform)
+            .forEach(line -> {
+                try {
+                    writer.write(line);
+                    writer.newLine();
+                } catch (IOException e) {
+                    throw new UncheckedIOException(e);
+                }
+            });
+    } catch (IOException e) {
+        throw new AppException(ErrorCode.IO_ERROR, "Failed to process file", e);
+    }
+}
+
+// Wrapping checked exceptions
+public User parseUser(String json) {
+    try {
+        return objectMapper.readValue(json, User.class);
+    } catch (JsonProcessingException e) {
+        throw new AppException(ErrorCode.PARSE_ERROR, "Invalid JSON", e);
+    }
+}
+\`\`\`
+
+## Collections
+\`\`\`java
+import java.util.*;
+
+// Immutable collections (Java 9+)
+List<String> names = List.of("Alice", "Bob", "Charlie");
+Set<Integer> numbers = Set.of(1, 2, 3);
+Map<String, Integer> scores = Map.of("Alice", 100, "Bob", 85);
+
+// Mutable when needed
+List<String> mutableList = new ArrayList<>(names);
+mutableList.add("David");
+
+// Map operations
+Map<String, User> userCache = new HashMap<>();
+
+// computeIfAbsent - lazy initialization
+User user = userCache.computeIfAbsent(userId, id -> repository.findById(id).orElse(null));
+
+// getOrDefault
+int count = countMap.getOrDefault(key, 0);
+
+// merge - accumulating values
+wordCounts.merge(word, 1, Integer::sum);
+
+// Concurrent collections
+Map<String, User> concurrentCache = new ConcurrentHashMap<>();
+Queue<Task> taskQueue = new ConcurrentLinkedQueue<>();
+\`\`\`
+
+## Testing with JUnit 5
+\`\`\`java
+import org.junit.jupiter.api.*;
+import org.junit.jupiter.params.ParameterizedTest;
+import org.junit.jupiter.params.provider.*;
+import static org.assertj.core.api.Assertions.*;
+import static org.mockito.Mockito.*;
+
+class UserServiceTest {
+    private UserRepository repository;
+    private UserService service;
+
+    @BeforeEach
+    void setUp() {
+        repository = mock(UserRepository.class);
+        service = new UserService(repository);
+    }
+
+    @Test
+    @DisplayName("findById returns user when exists")
+    void findById_whenUserExists_returnsUser() {
+        var user = new User("1", "test@example.com", "Test", true, Instant.now());
+        when(repository.findById("1")).thenReturn(Optional.of(user));
+
+        var result = service.findById("1");
+
+        assertThat(result).isPresent();
+        assertThat(result.get().email()).isEqualTo("test@example.com");
+    }
+
+    @Test
+    @DisplayName("getUser throws NotFoundException when not exists")
+    void getUser_whenNotExists_throwsException() {
+        when(repository.findById("999")).thenReturn(Optional.empty());
+
+        assertThatThrownBy(() -> service.getUser("999"))
+            .isInstanceOf(NotFoundException.class)
+            .hasMessageContaining("999");
+    }
+
+    @ParameterizedTest
+    @ValueSource(strings = {"", " ", "invalid-email"})
+    @DisplayName("validateEmail rejects invalid emails")
+    void validateEmail_withInvalidEmails_returnsFalse(String email) {
+        assertThat(service.validateEmail(email)).isFalse();
+    }
+
+    @ParameterizedTest
+    @CsvSource({
+        "test@example.com, true",
+        "user@domain.org, true",
+        "invalid, false",
+        ", false"
+    })
+    void validateEmail_withVariousInputs(String email, boolean expected) {
+        assertThat(service.validateEmail(email)).isEqualTo(expected);
+    }
+
+    @Test
+    void createUser_savesAndReturnsUser() {
+        var request = new CreateUserRequest("test@example.com", "Test", "password123");
+        when(repository.save(any(User.class))).thenAnswer(inv -> inv.getArgument(0));
+
+        var result = service.createUser(request);
+
+        assertThat(result.email()).isEqualTo("test@example.com");
+        verify(repository).save(any(User.class));
+    }
+
+    @Nested
+    @DisplayName("when user is admin")
+    class WhenAdmin {
+        @Test
+        void canDeleteOtherUsers() {
+            // ...
+        }
+    }
+}
+\`\`\`
+
+## ✅ DO
+- Use records for immutable data carriers (DTOs, value objects)
+- Use Optional for return types that may have no value
+- Use streams for collection transformations
+- Use var for local variables with obvious types
+- Use try-with-resources for AutoCloseable resources
+- Prefer List.of(), Set.of(), Map.of() for immutable collections
+- Use @DisplayName for readable test names
+
+## ❌ DON'T
+- Don't use Optional.get() - use orElseThrow() instead
+- Don't use Optional as field types or method parameters
+- Don't use null when Optional is appropriate
+- Don't mutate collections during stream operations
+- Don't use raw types (List instead of List<String>)
+- Don't catch Exception or Throwable generically
+- Don't use parallel streams for I/O operations

package/.claude/skills/jest.md

@@ -0,0 +1,313 @@
+# Jest Skill
+
+## Test Structure
+\`\`\`typescript
+describe('UserService', () => {
+  let service: UserService;
+  let mockDb: jest.Mocked<Database>;
+
+  // Setup before each test
+  beforeEach(() => {
+    mockDb = { findUser: jest.fn(), saveUser: jest.fn() } as any;
+    service = new UserService(mockDb);
+  });
+
+  // Cleanup after each test
+  afterEach(() => {
+    jest.clearAllMocks();
+  });
+
+  describe('getUser', () => {
+    it('should return user when found', async () => {
+      // Arrange
+      mockDb.findUser.mockResolvedValue({ id: '1', name: 'Test' });
+
+      // Act
+      const result = await service.getUser('1');
+
+      // Assert
+      expect(result).toEqual({ id: '1', name: 'Test' });
+      expect(mockDb.findUser).toHaveBeenCalledWith('1');
+      expect(mockDb.findUser).toHaveBeenCalledTimes(1);
+    });
+
+    it('should throw when user not found', async () => {
+      mockDb.findUser.mockResolvedValue(null);
+
+      await expect(service.getUser('1')).rejects.toThrow('Not found');
+    });
+  });
+});
+\`\`\`
+
+## Mocking
+
+### Function Mocks
+\`\`\`typescript
+// Basic mock
+const mockFn = jest.fn();
+mockFn.mockReturnValue('default');
+mockFn.mockReturnValueOnce('first call');
+
+// Async mock
+const mockAsync = jest.fn();
+mockAsync.mockResolvedValue({ data: 'success' });
+mockAsync.mockRejectedValue(new Error('Failed'));
+
+// Implementation mock
+const mockImpl = jest.fn((x: number) => x * 2);
+
+// Assertions
+expect(mockFn).toHaveBeenCalled();
+expect(mockFn).toHaveBeenCalledWith('arg1', 'arg2');
+expect(mockFn).toHaveBeenCalledTimes(2);
+expect(mockFn).toHaveBeenLastCalledWith('lastArg');
+expect(mockFn).toHaveReturnedWith('value');
+\`\`\`
+
+### Module Mocks
+\`\`\`typescript
+// Mock entire module
+jest.mock('./userService');
+import { UserService } from './userService';
+const MockedUserService = UserService as jest.MockedClass<typeof UserService>;
+
+// Mock with implementation
+jest.mock('./api', () => ({
+  fetchUser: jest.fn().mockResolvedValue({ id: '1', name: 'Test' }),
+  fetchPosts: jest.fn(),
+}));
+
+// Partial mock (keep some real implementations)
+jest.mock('./utils', () => ({
+  ...jest.requireActual('./utils'),
+  formatDate: jest.fn().mockReturnValue('2024-01-01'),
+}));
+
+// Mock default export
+jest.mock('./config', () => ({
+  __esModule: true,
+  default: { apiUrl: 'http://test.com' },
+}));
+\`\`\`
+
+### Spy on Methods
+\`\`\`typescript
+// Spy on object method
+const spy = jest.spyOn(console, 'log');
+spy.mockImplementation(() => {}); // Suppress output
+
+// Spy on prototype
+const saveSpy = jest.spyOn(UserService.prototype, 'save');
+saveSpy.mockResolvedValue({ id: '1' });
+
+// Restore original
+spy.mockRestore();
+\`\`\`
+
+## Async Testing
+\`\`\`typescript
+// Async/await
+it('should fetch data', async () => {
+  const data = await fetchData();
+  expect(data).toEqual({ id: 1 });
+});
+
+// Promises
+it('should resolve', () => {
+  return expect(fetchData()).resolves.toEqual({ id: 1 });
+});
+
+it('should reject', () => {
+  return expect(fetchData()).rejects.toThrow('Error');
+});
+
+// Callbacks (use done)
+it('should callback', (done) => {
+  fetchWithCallback((err, data) => {
+    expect(err).toBeNull();
+    expect(data).toEqual({ id: 1 });
+    done();
+  });
+});
+
+// Wait for assertions
+it('should eventually update', async () => {
+  const result = await waitFor(() => {
+    expect(element).toHaveTextContent('Updated');
+  });
+});
+\`\`\`
+
+## Timer Mocks
+\`\`\`typescript
+beforeEach(() => {
+  jest.useFakeTimers();
+});
+
+afterEach(() => {
+  jest.useRealTimers();
+});
+
+it('should debounce calls', () => {
+  const callback = jest.fn();
+  const debounced = debounce(callback, 1000);
+
+  debounced();
+  debounced();
+  debounced();
+
+  expect(callback).not.toHaveBeenCalled();
+
+  jest.advanceTimersByTime(1000);
+
+  expect(callback).toHaveBeenCalledTimes(1);
+});
+
+it('should handle setTimeout', () => {
+  const callback = jest.fn();
+  setTimeout(callback, 5000);
+
+  jest.runAllTimers(); // Run all pending timers
+  // Or: jest.advanceTimersByTime(5000);
+
+  expect(callback).toHaveBeenCalled();
+});
+
+// For Date mocking
+jest.setSystemTime(new Date('2024-01-15'));
+\`\`\`
+
+## Snapshot Testing
+\`\`\`typescript
+// Component snapshot
+it('should match snapshot', () => {
+  const tree = renderer.create(<Button label="Click me" />).toJSON();
+  expect(tree).toMatchSnapshot();
+});
+
+// Inline snapshot
+it('should match inline snapshot', () => {
+  expect(formatUser(user)).toMatchInlineSnapshot(\`
+    {
+      "name": "John Doe",
+      "email": "john@example.com"
+    }
+  \`);
+});
+
+// Update snapshots: jest --updateSnapshot or jest -u
+\`\`\`
+
+## Test Utilities
+\`\`\`typescript
+// Test each (parameterized tests)
+describe.each([
+  { input: 1, expected: 2 },
+  { input: 2, expected: 4 },
+  { input: 3, expected: 6 },
+])('double($input)', ({ input, expected }) => {
+  it(\`should return \${expected}\`, () => {
+    expect(double(input)).toBe(expected);
+  });
+});
+
+// Table syntax
+it.each\`
+  a    | b    | expected
+  \${1} | \${2} | \${3}
+  \${2} | \${3} | \${5}
+\`('add($a, $b) = $expected', ({ a, b, expected }) => {
+  expect(add(a, b)).toBe(expected);
+});
+
+// Skip and focus
+describe.skip('skipped suite', () => {});
+it.skip('skipped test', () => {});
+describe.only('focused suite', () => {}); // Only run this
+it.only('focused test', () => {}); // Only run this
+
+// Conditional tests
+const itif = (condition: boolean) => condition ? it : it.skip;
+itif(process.env.CI)('only runs in CI', () => {});
+\`\`\`
+
+## Common Matchers
+\`\`\`typescript
+// Equality
+expect(value).toBe(exact);           // Strict equality (===)
+expect(value).toEqual(object);       // Deep equality
+expect(value).toStrictEqual(object); // Deep equality + type checking
+
+// Truthiness
+expect(value).toBeTruthy();
+expect(value).toBeFalsy();
+expect(value).toBeNull();
+expect(value).toBeUndefined();
+expect(value).toBeDefined();
+
+// Numbers
+expect(value).toBeGreaterThan(3);
+expect(value).toBeGreaterThanOrEqual(3);
+expect(value).toBeLessThan(5);
+expect(value).toBeCloseTo(0.3, 5); // Floating point
+
+// Strings
+expect(value).toMatch(/pattern/);
+expect(value).toContain('substring');
+
+// Arrays/Iterables
+expect(array).toContain(item);
+expect(array).toContainEqual({ id: 1 });
+expect(array).toHaveLength(3);
+
+// Objects
+expect(object).toHaveProperty('key');
+expect(object).toHaveProperty('nested.key', 'value');
+expect(object).toMatchObject({ partial: 'match' });
+
+// Errors
+expect(() => fn()).toThrow();
+expect(() => fn()).toThrow(Error);
+expect(() => fn()).toThrow('message');
+expect(() => fn()).toThrow(/pattern/);
+
+// Negation
+expect(value).not.toBe(other);
+\`\`\`
+
+## Configuration (jest.config.js)
+\`\`\`javascript
+module.exports = {
+  preset: 'ts-jest',
+  testEnvironment: 'node', // or 'jsdom' for browser
+  roots: ['<rootDir>/src'],
+  testMatch: ['**/*.test.ts', '**/*.spec.ts'],
+  collectCoverageFrom: ['src/**/*.ts', '!src/**/*.d.ts'],
+  coverageThreshold: {
+    global: { branches: 80, functions: 80, lines: 80, statements: 80 },
+  },
+  setupFilesAfterEnv: ['<rootDir>/jest.setup.ts'],
+  moduleNameMapper: {
+    '^@/(.*)$': '<rootDir>/src/$1',
+  },
+};
+\`\`\`
+
+## ❌ DON'T
+- Test implementation details
+- Share state between tests
+- Use \`.only\` in committed code
+- Write flaky tests (timing-dependent)
+- Mock everything (test real integrations too)
+- Skip error case testing
+
+## ✅ DO
+- Follow Arrange-Act-Assert pattern
+- Use descriptive test names
+- Test behavior and outcomes
+- Clear mocks between tests
+- Test edge cases and errors
+- Keep tests independent and isolated
+- Use \`describe\` blocks to organize related tests
+- Aim for meaningful coverage, not 100%