autoworkflow 3.1.5 → 3.6.0

package/.claude/skills/angular.md

@@ -0,0 +1,237 @@
+# Angular Skill
+
+## Component Structure
+\`\`\`typescript
+@Component({
+  selector: 'app-user-card',
+  standalone: true,
+  imports: [CommonModule],
+  template: \`
+    <div class="card">
+      <h2>{{ user()?.name }}</h2>
+      <button (click)="increment()">Count: {{ count() }}</button>
+      <p>Double: {{ doubleCount() }}</p>
+    </div>
+  \`
+})
+export class UserCardComponent {
+  private userService = inject(UserService);
+
+  // Signals (Angular 16+)
+  count = signal(0);
+  user = signal<User | null>(null);
+  doubleCount = computed(() => this.count() * 2);
+
+  // Input signals (Angular 17+)
+  userId = input.required<string>();
+  initialCount = input(0);
+
+  // Output
+  countChange = output<number>();
+
+  increment() {
+    this.count.update(c => c + 1);
+    this.countChange.emit(this.count());
+  }
+
+  constructor() {
+    // Effect for side effects
+    effect(() => {
+      console.log('Count changed:', this.count());
+    });
+  }
+}
+\`\`\`
+
+## Services & Dependency Injection
+\`\`\`typescript
+// user.service.ts
+@Injectable({ providedIn: 'root' })
+export class UserService {
+  private http = inject(HttpClient);
+  private apiUrl = '/api/users';
+
+  getUsers(): Observable<User[]> {
+    return this.http.get<User[]>(this.apiUrl);
+  }
+
+  getUser(id: string): Observable<User> {
+    return this.http.get<User>(\`\${this.apiUrl}/\${id}\`);
+  }
+
+  createUser(user: CreateUserDto): Observable<User> {
+    return this.http.post<User>(this.apiUrl, user);
+  }
+}
+
+// Usage in component
+export class UsersComponent {
+  private userService = inject(UserService);
+
+  users = signal<User[]>([]);
+  loading = signal(true);
+
+  constructor() {
+    this.userService.getUsers().subscribe({
+      next: (users) => this.users.set(users),
+      complete: () => this.loading.set(false)
+    });
+  }
+}
+\`\`\`
+
+## Routing
+\`\`\`typescript
+// app.routes.ts
+export const routes: Routes = [
+  { path: '', component: HomeComponent },
+  { path: 'users', component: UsersComponent },
+  { path: 'users/:id', component: UserDetailComponent },
+  {
+    path: 'admin',
+    loadComponent: () => import('./admin/admin.component'),
+    canActivate: [authGuard],
+    children: [
+      { path: 'dashboard', component: DashboardComponent }
+    ]
+  },
+  { path: '**', component: NotFoundComponent }
+];
+
+// Route guard
+export const authGuard: CanActivateFn = (route, state) => {
+  const authService = inject(AuthService);
+  const router = inject(Router);
+
+  if (authService.isLoggedIn()) {
+    return true;
+  }
+
+  return router.createUrlTree(['/login'], {
+    queryParams: { returnUrl: state.url }
+  });
+};
+
+// Accessing route params
+export class UserDetailComponent {
+  private route = inject(ActivatedRoute);
+
+  userId = input.required<string>(); // With input binding
+  // Or from route snapshot:
+  // userId = this.route.snapshot.paramMap.get('id');
+}
+\`\`\`
+
+## Reactive Forms
+\`\`\`typescript
+@Component({
+  standalone: true,
+  imports: [ReactiveFormsModule],
+  template: \`
+    <form [formGroup]="form" (ngSubmit)="onSubmit()">
+      <input formControlName="email" />
+      @if (form.get('email')?.errors?.['required']) {
+        <span class="error">Email is required</span>
+      }
+      @if (form.get('email')?.errors?.['email']) {
+        <span class="error">Invalid email</span>
+      }
+
+      <input type="password" formControlName="password" />
+
+      <button type="submit" [disabled]="form.invalid">Submit</button>
+    </form>
+  \`
+})
+export class LoginComponent {
+  private fb = inject(FormBuilder);
+
+  form = this.fb.group({
+    email: ['', [Validators.required, Validators.email]],
+    password: ['', [Validators.required, Validators.minLength(8)]]
+  });
+
+  onSubmit() {
+    if (this.form.valid) {
+      console.log(this.form.value);
+    }
+  }
+}
+\`\`\`
+
+## HTTP Interceptors
+\`\`\`typescript
+// auth.interceptor.ts
+export const authInterceptor: HttpInterceptorFn = (req, next) => {
+  const authService = inject(AuthService);
+  const token = authService.getToken();
+
+  if (token) {
+    req = req.clone({
+      setHeaders: { Authorization: \`Bearer \${token}\` }
+    });
+  }
+
+  return next(req).pipe(
+    catchError((error: HttpErrorResponse) => {
+      if (error.status === 401) {
+        authService.logout();
+      }
+      return throwError(() => error);
+    })
+  );
+};
+
+// Register in app.config.ts
+export const appConfig: ApplicationConfig = {
+  providers: [
+    provideHttpClient(withInterceptors([authInterceptor])),
+    provideRouter(routes)
+  ]
+};
+\`\`\`
+
+## RxJS Patterns
+\`\`\`typescript
+// Search with debounce
+searchTerm = new Subject<string>();
+
+results$ = this.searchTerm.pipe(
+  debounceTime(300),
+  distinctUntilChanged(),
+  switchMap(term => this.searchService.search(term))
+);
+
+// Combine observables
+user$ = combineLatest([
+  this.userService.getUser(this.userId),
+  this.userService.getUserPosts(this.userId)
+]).pipe(
+  map(([user, posts]) => ({ ...user, posts }))
+);
+
+// Auto-unsubscribe with takeUntilDestroyed
+export class MyComponent {
+  private destroyRef = inject(DestroyRef);
+
+  ngOnInit() {
+    interval(1000).pipe(
+      takeUntilDestroyed(this.destroyRef)
+    ).subscribe(console.log);
+  }
+}
+\`\`\`
+
+## ❌ DON'T
+- Use constructor for complex logic (use inject())
+- Forget to unsubscribe from observables
+- Use NgModules for new projects (use standalone)
+- Mutate signal values directly
+
+## ✅ DO
+- Use standalone components
+- Use signals for reactive state
+- Use inject() for DI
+- Use functional guards and interceptors
+- Use takeUntilDestroyed for cleanup
+- Use control flow (@if, @for) instead of *ngIf, *ngFor

package/.claude/skills/api-design.md

@@ -0,0 +1,187 @@
+# API Design Skill
+
+## REST Best Practices
+\`\`\`
+GET    /users          → List users
+GET    /users/:id      → Get single user
+POST   /users          → Create user
+PUT    /users/:id      → Update user (full)
+PATCH  /users/:id      → Update user (partial)
+DELETE /users/:id      → Delete user
+
+Nested Resources:
+GET    /users/:id/posts     → List user's posts
+POST   /users/:id/posts     → Create post for user
+\`\`\`
+
+## Status Codes
+\`\`\`
+2xx Success:
+  200 OK              - Success with body
+  201 Created         - Resource created (include Location header)
+  204 No Content      - Success, no body (DELETE, PUT)
+
+4xx Client Errors:
+  400 Bad Request     - Invalid input/validation failed
+  401 Unauthorized    - Not authenticated
+  403 Forbidden       - Not authorized for this resource
+  404 Not Found       - Resource doesn't exist
+  409 Conflict        - Duplicate resource (e.g., email exists)
+  422 Unprocessable   - Validation error (alternative to 400)
+  429 Too Many Reqs   - Rate limit exceeded
+
+5xx Server Errors:
+  500 Internal Error  - Server error (hide details from client)
+  503 Unavailable     - Maintenance/overload
+\`\`\`
+
+## Pagination Patterns
+
+### Offset-based (simple, but slow for large datasets)
+\`\`\`typescript
+// Request: GET /users?page=2&limit=20
+// Response:
+{
+  "data": [...],
+  "pagination": {
+    "page": 2,
+    "limit": 20,
+    "total": 150,
+    "totalPages": 8
+  }
+}
+\`\`\`
+
+### Cursor-based (better for large/real-time data)
+\`\`\`typescript
+// Request: GET /users?cursor=abc123&limit=20
+// Response:
+{
+  "data": [...],
+  "pagination": {
+    "nextCursor": "def456",
+    "prevCursor": "xyz789",
+    "hasMore": true
+  }
+}
+
+// Implementation
+const users = await prisma.user.findMany({
+  take: limit + 1, // Fetch one extra to check hasMore
+  cursor: cursor ? { id: cursor } : undefined,
+  orderBy: { createdAt: 'desc' }
+});
+
+const hasMore = users.length > limit;
+const data = hasMore ? users.slice(0, -1) : users;
+const nextCursor = hasMore ? data[data.length - 1].id : null;
+\`\`\`
+
+## Filtering & Sorting
+\`\`\`typescript
+// Request: GET /users?status=active&role=admin&sort=-createdAt,name
+
+// Parse and validate query params
+const filters = {
+  status: z.enum(['active', 'inactive']).optional(),
+  role: z.enum(['user', 'admin']).optional(),
+  search: z.string().max(100).optional(),
+};
+
+const sortFields = ['createdAt', 'name', 'email'];
+// - prefix means descending: -createdAt
+
+// Response includes applied filters
+{
+  "data": [...],
+  "filters": { "status": "active", "role": "admin" },
+  "sort": ["-createdAt", "name"]
+}
+\`\`\`
+
+## Error Response Format
+\`\`\`json
+{
+  "error": {
+    "code": "VALIDATION_ERROR",
+    "message": "Invalid input data",
+    "details": [
+      { "field": "email", "message": "Invalid email format" },
+      { "field": "age", "message": "Must be a positive number" }
+    ],
+    "requestId": "req_abc123"
+  }
+}
+\`\`\`
+
+## Rate Limiting Headers
+\`\`\`
+X-RateLimit-Limit: 100        # Max requests per window
+X-RateLimit-Remaining: 45     # Remaining requests
+X-RateLimit-Reset: 1640000000 # Unix timestamp when window resets
+Retry-After: 60               # Seconds until retry (on 429)
+\`\`\`
+
+## API Versioning Strategies
+\`\`\`
+1. URL Path (recommended):
+   /api/v1/users
+   /api/v2/users
+
+2. Header:
+   Accept: application/vnd.myapi.v1+json
+
+3. Query Parameter:
+   /api/users?version=1
+\`\`\`
+
+## Request/Response Examples
+\`\`\`typescript
+// POST /api/v1/users
+// Request:
+{
+  "email": "user@example.com",
+  "name": "John Doe",
+  "role": "user"
+}
+
+// Response: 201 Created
+// Headers: Location: /api/v1/users/123
+{
+  "id": "123",
+  "email": "user@example.com",
+  "name": "John Doe",
+  "role": "user",
+  "createdAt": "2024-01-15T10:30:00Z"
+}
+
+// GET /api/v1/users/123
+// Response: 200 OK
+{
+  "id": "123",
+  "email": "user@example.com",
+  "name": "John Doe",
+  "role": "user",
+  "createdAt": "2024-01-15T10:30:00Z",
+  "_links": {
+    "self": "/api/v1/users/123",
+    "posts": "/api/v1/users/123/posts"
+  }
+}
+\`\`\`
+
+## ❌ DON'T
+- Use verbs in URLs (POST /createUser)
+- Return 200 for errors
+- Ignore pagination for list endpoints
+- Expose internal IDs or stack traces
+- Change API without versioning
+
+## ✅ DO
+- Version your APIs (/api/v1/)
+- Document with OpenAPI
+- Use consistent naming (plural nouns)
+- Implement pagination for all lists
+- Add rate limiting with headers
+- Include request IDs for debugging
+- Use ISO 8601 for dates