autoworkflow 3.1.5 → 3.5.0

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

@@ -0,0 +1,262 @@
+# MCP Slack Skill
+
+## Server Configuration
+\`\`\`json
+// claude_desktop_config.json or .claude/settings.json
+{
+  "mcpServers": {
+    "slack": {
+      "command": "npx",
+      "args": ["-y", "@modelcontextprotocol/server-slack"],
+      "env": {
+        "SLACK_BOT_TOKEN": "xoxb-xxxxxxxxxxxx",
+        "SLACK_TEAM_ID": "T0XXXXXXX"
+      }
+    }
+  }
+}
+\`\`\`
+
+## Authentication Setup
+\`\`\`bash
+# 1. Create a Slack App at https://api.slack.com/apps
+# 2. Add Bot Token Scopes under OAuth & Permissions:
+#    - channels:history (read public channel messages)
+#    - channels:read (list public channels)
+#    - chat:write (post messages)
+#    - files:read (access files)
+#    - files:write (upload files)
+#    - groups:history (read private channel messages)
+#    - groups:read (list private channels)
+#    - im:history (read DMs)
+#    - im:read (list DMs)
+#    - users:read (list users)
+#    - reactions:read (access reactions)
+#    - reactions:write (add reactions)
+# 3. Install app to workspace
+# 4. Copy Bot User OAuth Token (xoxb-...)
+\`\`\`
+
+## Available Tools
+
+### Channel Operations
+\`\`\`
+list_channels
+- types?: 'public_channel' | 'private_channel' | 'mpim' | 'im'
+- limit?: number (default 100)
+- Returns: array of channels with id, name, topic
+
+get_channel_info
+- channel: string (channel ID)
+- Returns: channel details
+
+get_channel_history
+- channel: string (channel ID)
+- limit?: number (default 100)
+- oldest?: string (timestamp)
+- latest?: string (timestamp)
+- Returns: array of messages
+
+join_channel
+- channel: string (channel ID)
+- Returns: success status
+\`\`\`
+
+### Message Operations
+\`\`\`
+post_message
+- channel: string (channel ID or name)
+- text: string (message content)
+- thread_ts?: string (reply to thread)
+- unfurl_links?: boolean
+- unfurl_media?: boolean
+- Returns: message timestamp
+
+update_message
+- channel: string
+- ts: string (message timestamp)
+- text: string (new content)
+- Returns: updated message
+
+delete_message
+- channel: string
+- ts: string (message timestamp)
+- Returns: success status
+
+reply_to_thread
+- channel: string
+- thread_ts: string (parent message timestamp)
+- text: string
+- Returns: message timestamp
+
+get_thread_replies
+- channel: string
+- ts: string (thread parent timestamp)
+- Returns: array of reply messages
+\`\`\`
+
+### Reaction Operations
+\`\`\`
+add_reaction
+- channel: string
+- timestamp: string (message ts)
+- name: string (emoji name without colons)
+
+remove_reaction
+- channel: string
+- timestamp: string
+- name: string
+
+get_reactions
+- channel: string
+- timestamp: string
+- Returns: array of reactions
+\`\`\`
+
+### User Operations
+\`\`\`
+list_users
+- limit?: number
+- Returns: array of users with id, name, real_name, email
+
+get_user_info
+- user: string (user ID)
+- Returns: user profile details
+
+get_user_by_email
+- email: string
+- Returns: user information
+\`\`\`
+
+### File Operations
+\`\`\`
+upload_file
+- channels: string (comma-separated channel IDs)
+- content?: string (file content)
+- filename: string
+- filetype?: string
+- title?: string
+- initial_comment?: string
+- Returns: file info
+
+list_files
+- channel?: string
+- user?: string
+- types?: string (e.g., 'images', 'pdfs')
+- Returns: array of files
+\`\`\`
+
+## Message Formatting
+
+### Block Kit Basics
+\`\`\`json
+{
+  "blocks": [
+    {
+      "type": "header",
+      "text": {
+        "type": "plain_text",
+        "text": "Deployment Complete"
+      }
+    },
+    {
+      "type": "section",
+      "text": {
+        "type": "mrkdwn",
+        "text": "*Status:* :white_check_mark: Success\\n*Environment:* Production"
+      }
+    },
+    {
+      "type": "divider"
+    },
+    {
+      "type": "section",
+      "fields": [
+        { "type": "mrkdwn", "text": "*Version:* v2.3.1" },
+        { "type": "mrkdwn", "text": "*Duration:* 3m 42s" }
+      ]
+    },
+    {
+      "type": "actions",
+      "elements": [
+        {
+          "type": "button",
+          "text": { "type": "plain_text", "text": "View Logs" },
+          "url": "https://logs.example.com"
+        }
+      ]
+    }
+  ]
+}
+\`\`\`
+
+### Markdown Formatting
+\`\`\`
+*bold*
+_italic_
+~strikethrough~
+\`code\`
+\`\`\`code block\`\`\`
+> quote
+<https://example.com|Link Text>
+<@U12345> (mention user)
+<#C12345> (mention channel)
+<!here> <!channel> <!everyone> (special mentions)
+:emoji_name: (emoji)
+\`\`\`
+
+## Common Workflows
+
+### Post Build Notification
+\`\`\`
+1. Use list_channels to find #deployments channel
+2. Use post_message with Block Kit:
+   - Header: "Build #123 Complete"
+   - Status, branch, commit info
+   - Link to build logs
+   - Actions: View Diff, Rollback
+\`\`\`
+
+### Daily Standup Reminder
+\`\`\`
+1. Get channel history from yesterday
+2. Summarize activity
+3. Post formatted standup prompt
+4. Add reaction for acknowledgment tracking
+\`\`\`
+
+### Error Alert Thread
+\`\`\`
+1. Post main alert message
+2. Store thread_ts from response
+3. Add error details as thread replies
+4. Add reactions for status tracking
+   - :eyes: (investigating)
+   - :white_check_mark: (resolved)
+\`\`\`
+
+## Channel ID Lookup
+\`\`\`bash
+# Channel IDs start with C (public) or G (private)
+# Find channel ID:
+# 1. Right-click channel > View channel details
+# 2. Copy channel ID from bottom of modal
+
+# Or use list_channels tool to search by name
+\`\`\`
+
+## ❌ DON'T
+- Post sensitive data (tokens, passwords) in channels
+- Spam channels with excessive notifications
+- Use @channel/@here for non-urgent messages
+- Store bot tokens in code
+- Ignore rate limits (Tier 1: 1 req/sec)
+
+## ✅ DO
+- Use threads to organize related messages
+- Format messages with Block Kit for readability
+- Use appropriate emoji reactions for status
+- Batch notifications where possible
+- Respect rate limits with backoff
+- Use channel-specific tokens when needed
+- Archive notifications after resolution

package/.claude/skills/micronaut.md

@@ -0,0 +1,388 @@
+# Micronaut Skill
+
+## Project Setup
+\`\`\`bash
+# Create new project
+mn create-app com.example.myapp --features=data-jdbc,postgres,security-jwt
+
+# Run with hot reload
+./gradlew run --continuous
+
+# Build native image
+./gradlew nativeCompile
+\`\`\`
+
+## Controller
+\`\`\`java
+@Controller("/api/v1/users")
+public class UserController {
+
+    private final UserService userService;
+
+    public UserController(UserService userService) {
+        this.userService = userService;
+    }
+
+    @Get
+    public Page<UserResponse> listUsers(
+            @QueryValue(defaultValue = "0") int page,
+            @QueryValue(defaultValue = "20") int size) {
+        return userService.findAll(Pageable.from(page, size));
+    }
+
+    @Get("/{id}")
+    public HttpResponse<UserResponse> getUser(@PathVariable String id) {
+        return userService.findById(id)
+            .map(HttpResponse::ok)
+            .orElse(HttpResponse.notFound());
+    }
+
+    @Post
+    public HttpResponse<UserResponse> createUser(@Valid @Body CreateUserRequest request) {
+        UserResponse user = userService.create(request);
+        return HttpResponse.created(user)
+            .header("Location", "/api/v1/users/" + user.id());
+    }
+
+    @Put("/{id}")
+    public HttpResponse<UserResponse> updateUser(
+            @PathVariable String id,
+            @Valid @Body UpdateUserRequest request) {
+        return HttpResponse.ok(userService.update(id, request));
+    }
+
+    @Delete("/{id}")
+    public HttpResponse<Void> deleteUser(@PathVariable String id) {
+        userService.delete(id);
+        return HttpResponse.noContent();
+    }
+}
+\`\`\`
+
+## Reactive Controller
+\`\`\`java
+@Controller("/api/v1/users")
+public class UserController {
+
+    private final UserService userService;
+
+    public UserController(UserService userService) {
+        this.userService = userService;
+    }
+
+    @Get
+    public Flux<UserResponse> listUsers() {
+        return userService.findAllReactive();
+    }
+
+    @Get("/{id}")
+    public Mono<HttpResponse<UserResponse>> getUser(@PathVariable String id) {
+        return userService.findByIdReactive(id)
+            .map(HttpResponse::ok)
+            .defaultIfEmpty(HttpResponse.notFound());
+    }
+
+    @Post
+    public Mono<HttpResponse<UserResponse>> createUser(@Valid @Body CreateUserRequest request) {
+        return userService.createReactive(request)
+            .map(user -> HttpResponse.created(user));
+    }
+}
+\`\`\`
+
+## Data Access with Micronaut Data
+\`\`\`java
+// Entity
+@MappedEntity("users")
+public class User {
+
+    @Id
+    @GeneratedValue(GeneratedValue.Type.UUID)
+    private String id;
+
+    @Column("email")
+    private String email;
+
+    @Column("name")
+    private String name;
+
+    @Column("password_hash")
+    private String passwordHash;
+
+    @Column("is_active")
+    private boolean isActive = true;
+
+    @DateCreated
+    @Column("created_at")
+    private Instant createdAt;
+
+    @DateUpdated
+    @Column("updated_at")
+    private Instant updatedAt;
+
+    // Getters and setters...
+}
+
+// Repository
+@JdbcRepository(dialect = Dialect.POSTGRES)
+public interface UserRepository extends PageableRepository<User, String> {
+
+    Optional<User> findByEmail(String email);
+
+    List<User> findByIsActiveTrue();
+
+    @Query("SELECT * FROM users WHERE is_active = true ORDER BY created_at DESC")
+    List<User> findActiveUsers();
+
+    boolean existsByEmail(String email);
+
+    void updateName(@Id String id, String name);
+}
+
+// Reactive Repository
+@R2dbcRepository(dialect = Dialect.POSTGRES)
+public interface UserRepository extends ReactiveStreamsCrudRepository<User, String> {
+
+    Mono<User> findByEmail(String email);
+
+    Flux<User> findByIsActiveTrue();
+}
+\`\`\`
+
+## Service Layer
+\`\`\`java
+@Singleton
+public class UserService {
+
+    private final UserRepository userRepository;
+    private final PasswordEncoder passwordEncoder;
+
+    public UserService(UserRepository userRepository, PasswordEncoder passwordEncoder) {
+        this.userRepository = userRepository;
+        this.passwordEncoder = passwordEncoder;
+    }
+
+    public Page<UserResponse> findAll(Pageable pageable) {
+        return userRepository.findAll(pageable)
+            .map(UserResponse::from);
+    }
+
+    public Optional<UserResponse> findById(String id) {
+        return userRepository.findById(id)
+            .map(UserResponse::from);
+    }
+
+    @Transactional
+    public UserResponse create(CreateUserRequest request) {
+        if (userRepository.existsByEmail(request.email())) {
+            throw new ConflictException("Email already exists");
+        }
+
+        User user = new User();
+        user.setEmail(request.email());
+        user.setName(request.name());
+        user.setPasswordHash(passwordEncoder.encode(request.password()));
+
+        return UserResponse.from(userRepository.save(user));
+    }
+
+    @Transactional
+    public UserResponse update(String id, UpdateUserRequest request) {
+        User user = userRepository.findById(id)
+            .orElseThrow(() -> new NotFoundException("User not found: " + id));
+
+        if (request.name() != null) {
+            user.setName(request.name());
+        }
+        if (request.email() != null) {
+            user.setEmail(request.email());
+        }
+
+        return UserResponse.from(userRepository.update(user));
+    }
+
+    @Transactional
+    public void delete(String id) {
+        if (!userRepository.existsById(id)) {
+            throw new NotFoundException("User not found: " + id);
+        }
+        userRepository.deleteById(id);
+    }
+}
+\`\`\`
+
+## Exception Handling
+\`\`\`java
+@Produces
+@Singleton
+public class GlobalExceptionHandler {
+
+    @Error(global = true)
+    public HttpResponse<ErrorResponse> handleNotFound(
+            HttpRequest<?> request,
+            NotFoundException exception) {
+        return HttpResponse.notFound()
+            .body(new ErrorResponse("NOT_FOUND", exception.getMessage()));
+    }
+
+    @Error(global = true)
+    public HttpResponse<ErrorResponse> handleConflict(
+            HttpRequest<?> request,
+            ConflictException exception) {
+        return HttpResponse.status(HttpStatus.CONFLICT)
+            .body(new ErrorResponse("CONFLICT", exception.getMessage()));
+    }
+
+    @Error(global = true)
+    public HttpResponse<ValidationErrorResponse> handleValidation(
+            HttpRequest<?> request,
+            ConstraintViolationException exception) {
+        Map<String, String> errors = exception.getConstraintViolations().stream()
+            .collect(Collectors.toMap(
+                v -> v.getPropertyPath().toString(),
+                ConstraintViolation::getMessage
+            ));
+        return HttpResponse.badRequest()
+            .body(new ValidationErrorResponse("VALIDATION_ERROR", errors));
+    }
+}
+
+public record ErrorResponse(String code, String message) {}
+public record ValidationErrorResponse(String code, Map<String, String> errors) {}
+\`\`\`
+
+## Configuration
+\`\`\`yaml
+# application.yml
+micronaut:
+  application:
+    name: myapp
+  server:
+    port: 8080
+
+datasources:
+  default:
+    url: \${DATABASE_URL}
+    username: \${DATABASE_USER}
+    password: \${DATABASE_PASSWORD}
+    dialect: POSTGRES
+
+jpa:
+  default:
+    properties:
+      hibernate:
+        hbm2ddl:
+          auto: validate
+
+micronaut:
+  security:
+    authentication: bearer
+    token:
+      jwt:
+        signatures:
+          secret:
+            generator:
+              secret: \${JWT_SECRET}
+\`\`\`
+
+## Security
+\`\`\`java
+@Singleton
+public class AuthenticationProviderUserPassword implements AuthenticationProvider<HttpRequest<?>> {
+
+    private final UserRepository userRepository;
+    private final PasswordEncoder passwordEncoder;
+
+    public AuthenticationProviderUserPassword(
+            UserRepository userRepository,
+            PasswordEncoder passwordEncoder) {
+        this.userRepository = userRepository;
+        this.passwordEncoder = passwordEncoder;
+    }
+
+    @Override
+    public Publisher<AuthenticationResponse> authenticate(
+            HttpRequest<?> httpRequest,
+            AuthenticationRequest<?, ?> authRequest) {
+        return Flux.just(authRequest)
+            .flatMap(req -> {
+                String email = (String) req.getIdentity();
+                String password = (String) req.getSecret();
+
+                return userRepository.findByEmail(email)
+                    .filter(user -> passwordEncoder.matches(password, user.getPasswordHash()))
+                    .map(user -> AuthenticationResponse.success(user.getId()))
+                    .switchIfEmpty(Mono.just(AuthenticationResponse.failure()));
+            });
+    }
+}
+
+// Secured endpoint
+@Controller("/api/v1/admin")
+@Secured(SecurityRule.IS_AUTHENTICATED)
+public class AdminController {
+
+    @Get("/users")
+    @Secured({"ADMIN"})
+    public List<UserResponse> listAllUsers() {
+        // ...
+    }
+}
+\`\`\`
+
+## Testing
+\`\`\`java
+@MicronautTest
+class UserControllerTest {
+
+    @Inject
+    @Client("/")
+    HttpClient client;
+
+    @Inject
+    UserRepository userRepository;
+
+    @Test
+    void testGetUser() {
+        HttpResponse<UserResponse> response = client.toBlocking()
+            .exchange(HttpRequest.GET("/api/v1/users/1"), UserResponse.class);
+
+        assertEquals(HttpStatus.OK, response.getStatus());
+        assertNotNull(response.body());
+    }
+
+    @Test
+    void testCreateUser() {
+        var request = new CreateUserRequest("test@example.com", "Test", "password123");
+
+        HttpResponse<UserResponse> response = client.toBlocking()
+            .exchange(HttpRequest.POST("/api/v1/users", request), UserResponse.class);
+
+        assertEquals(HttpStatus.CREATED, response.getStatus());
+        assertTrue(response.header("Location").contains("/api/v1/users/"));
+    }
+
+    @Test
+    void testGetUserNotFound() {
+        HttpClientResponseException exception = assertThrows(
+            HttpClientResponseException.class,
+            () -> client.toBlocking().exchange(HttpRequest.GET("/api/v1/users/999"))
+        );
+
+        assertEquals(HttpStatus.NOT_FOUND, exception.getStatus());
+    }
+}
+\`\`\`
+
+## ✅ DO
+- Use constructor injection (Micronaut creates at compile time)
+- Use \`@Singleton\` for services (default scope)
+- Use Micronaut Data for repositories
+- Use \`@Error\` handlers for exception mapping
+- Return \`HttpResponse<T>\` for explicit status control
+
+## ❌ DON'T
+- Don't use field injection
+- Don't return null - use Optional or throw exceptions
+- Don't forget \`@Transactional\` for write operations
+- Don't use reflection-based libraries (breaks native image)