aigroup-workflow 2.1.2 → 2.2.1

package/skills/angular-architect/references/testing.md

@@ -1,405 +0,0 @@
-# Angular Testing
-
-## Component Testing
-
-```typescript
-import { ComponentFixture, TestBed } from '@angular/core/testing';
-import { signal } from '@angular/core';
-import { UserListComponent } from './user-list.component';
-import { UsersService } from './users.service';
-import { of } from 'rxjs';
-
-describe('UserListComponent', () => {
-  let component: UserListComponent;
-  let fixture: ComponentFixture<UserListComponent>;
-  let usersService: jasmine.SpyObj<UsersService>;
-
-  const mockUsers = [
-    { id: '1', name: 'John Doe', email: 'john@example.com' },
-    { id: '2', name: 'Jane Smith', email: 'jane@example.com' }
-  ];
-
-  beforeEach(async () => {
-    // Create spy object
-    const usersServiceSpy = jasmine.createSpyObj('UsersService', ['getAll', 'delete']);
-
-    await TestBed.configureTestingModule({
-      imports: [UserListComponent],  // Standalone component
-      providers: [
-        { provide: UsersService, useValue: usersServiceSpy }
-      ]
-    }).compileComponents();
-
-    usersService = TestBed.inject(UsersService) as jasmine.SpyObj<UsersService>;
-    fixture = TestBed.createComponent(UserListComponent);
-    component = fixture.componentInstance;
-  });
-
-  it('should create', () => {
-    expect(component).toBeTruthy();
-  });
-
-  it('should load users on init', () => {
-    usersService.getAll.and.returnValue(of(mockUsers));
-
-    fixture.detectChanges();  // Trigger ngOnInit
-
-    expect(usersService.getAll).toHaveBeenCalled();
-    expect(component.users()).toEqual(mockUsers);
-  });
-
-  it('should display users in template', () => {
-    component.users.set(mockUsers);
-    fixture.detectChanges();
-
-    const compiled = fixture.nativeElement;
-    const userElements = compiled.querySelectorAll('.user-item');
-
-    expect(userElements.length).toBe(2);
-    expect(userElements[0].textContent).toContain('John Doe');
-  });
-
-  it('should emit userSelected when user clicked', () => {
-    const emitSpy = spyOn(component.userSelected, 'emit');
-
-    component.onUserClick(mockUsers[0]);
-
-    expect(emitSpy).toHaveBeenCalledWith(mockUsers[0]);
-  });
-
-  it('should show loading state', () => {
-    component.loading.set(true);
-    fixture.detectChanges();
-
-    const compiled = fixture.nativeElement;
-    expect(compiled.querySelector('.loading')).toBeTruthy();
-  });
-});
-```
-
-## Service Testing
-
-```typescript
-import { TestBed } from '@angular/core/testing';
-import { HttpClientTestingModule, HttpTestingController } from '@angular/common/http/testing';
-import { UsersService } from './users.service';
-import { User } from './user.model';
-
-describe('UsersService', () => {
-  let service: UsersService;
-  let httpMock: HttpTestingController;
-
-  const mockUsers: User[] = [
-    { id: '1', name: 'John', email: 'john@example.com' },
-    { id: '2', name: 'Jane', email: 'jane@example.com' }
-  ];
-
-  beforeEach(() => {
-    TestBed.configureTestingModule({
-      imports: [HttpClientTestingModule],
-      providers: [UsersService]
-    });
-
-    service = TestBed.inject(UsersService);
-    httpMock = TestBed.inject(HttpTestingController);
-  });
-
-  afterEach(() => {
-    httpMock.verify();  // Verify no outstanding requests
-  });
-
-  it('should fetch all users', (done) => {
-    service.getAll().subscribe(users => {
-      expect(users).toEqual(mockUsers);
-      done();
-    });
-
-    const req = httpMock.expectOne('/api/users');
-    expect(req.request.method).toBe('GET');
-    req.flush(mockUsers);
-  });
-
-  it('should create a user', (done) => {
-    const newUser: User = { id: '3', name: 'Bob', email: 'bob@example.com' };
-
-    service.create(newUser).subscribe(user => {
-      expect(user).toEqual(newUser);
-      done();
-    });
-
-    const req = httpMock.expectOne('/api/users');
-    expect(req.request.method).toBe('POST');
-    expect(req.request.body).toEqual(newUser);
-    req.flush(newUser);
-  });
-
-  it('should handle error', (done) => {
-    service.getAll().subscribe({
-      next: () => fail('should have failed'),
-      error: (error) => {
-        expect(error.status).toBe(500);
-        done();
-      }
-    });
-
-    const req = httpMock.expectOne('/api/users');
-    req.flush('Server error', { status: 500, statusText: 'Internal Server Error' });
-  });
-});
-```
-
-## RxJS Marble Testing
-
-```typescript
-import { TestScheduler } from 'rxjs/testing';
-import { delay, map } from 'rxjs/operators';
-
-describe('RxJS Operators', () => {
-  let testScheduler: TestScheduler;
-
-  beforeEach(() => {
-    testScheduler = new TestScheduler((actual, expected) => {
-      expect(actual).toEqual(expected);
-    });
-  });
-
-  it('should map values', () => {
-    testScheduler.run(({ cold, expectObservable }) => {
-      const source$ = cold('--a--b--c--|', { a: 1, b: 2, c: 3 });
-      const expected = '    --x--y--z--|';
-      const result$ = source$.pipe(map(x => x * 10));
-
-      expectObservable(result$).toBe(expected, { x: 10, y: 20, z: 30 });
-    });
-  });
-
-  it('should delay emissions', () => {
-    testScheduler.run(({ cold, expectObservable }) => {
-      const source$ = cold('--a--b--|', { a: 1, b: 2 });
-      const expected = '    ----a--b--|';
-      const result$ = source$.pipe(delay(20));
-
-      expectObservable(result$).toBe(expected, { a: 1, b: 2 });
-    });
-  });
-});
-```
-
-## Testing with Signals
-
-```typescript
-import { signal } from '@angular/core';
-
-describe('Counter Component', () => {
-  it('should update signal value', () => {
-    const count = signal(0);
-
-    expect(count()).toBe(0);
-
-    count.set(5);
-    expect(count()).toBe(5);
-
-    count.update(val => val + 1);
-    expect(count()).toBe(6);
-  });
-
-  it('should compute derived value', () => {
-    const count = signal(5);
-    const doubled = computed(() => count() * 2);
-
-    expect(doubled()).toBe(10);
-
-    count.set(10);
-    expect(doubled()).toBe(20);
-  });
-});
-```
-
-## Testing NgRx
-
-```typescript
-import { TestBed } from '@angular/core/testing';
-import { provideMockStore, MockStore } from '@ngrx/store/testing';
-import { UsersComponent } from './users.component';
-import { selectAllUsers, selectUsersLoading } from './store/users.selectors';
-
-describe('UsersComponent with NgRx', () => {
-  let component: UsersComponent;
-  let fixture: ComponentFixture<UsersComponent>;
-  let store: MockStore;
-
-  const initialState = {
-    users: {
-      ids: ['1', '2'],
-      entities: {
-        '1': { id: '1', name: 'John' },
-        '2': { id: '2', name: 'Jane' }
-      },
-      loading: false
-    }
-  };
-
-  beforeEach(async () => {
-    await TestBed.configureTestingModule({
-      imports: [UsersComponent],
-      providers: [
-        provideMockStore({ initialState })
-      ]
-    }).compileComponents();
-
-    store = TestBed.inject(MockStore);
-    fixture = TestBed.createComponent(UsersComponent);
-    component = fixture.componentInstance;
-  });
-
-  it('should select users from store', () => {
-    store.overrideSelector(selectAllUsers, [
-      { id: '1', name: 'John' },
-      { id: '2', name: 'Jane' }
-    ]);
-
-    fixture.detectChanges();
-
-    expect(component.users().length).toBe(2);
-  });
-
-  it('should dispatch action on delete', () => {
-    const dispatchSpy = spyOn(store, 'dispatch');
-
-    component.onDelete('1');
-
-    expect(dispatchSpy).toHaveBeenCalledWith(
-      UsersActions.deleteUser({ id: '1' })
-    );
-  });
-});
-```
-
-## Testing Effects
-
-```typescript
-import { TestBed } from '@angular/core/testing';
-import { provideMockActions } from '@ngrx/effects/testing';
-import { Observable, of, throwError } from 'rxjs';
-import { UsersEffects } from './users.effects';
-import { UsersService } from './users.service';
-import { UsersActions } from './users.actions';
-import { hot, cold } from 'jasmine-marbles';
-
-describe('UsersEffects', () => {
-  let actions$: Observable<any>;
-  let effects: UsersEffects;
-  let usersService: jasmine.SpyObj<UsersService>;
-
-  beforeEach(() => {
-    const usersServiceSpy = jasmine.createSpyObj('UsersService', ['getAll']);
-
-    TestBed.configureTestingModule({
-      providers: [
-        UsersEffects,
-        provideMockActions(() => actions$),
-        { provide: UsersService, useValue: usersServiceSpy }
-      ]
-    });
-
-    effects = TestBed.inject(UsersEffects);
-    usersService = TestBed.inject(UsersService) as jasmine.SpyObj<UsersService>;
-  });
-
-  it('should load users successfully', () => {
-    const users = [{ id: '1', name: 'John' }];
-    const action = UsersActions.loadUsers();
-    const outcome = UsersActions.loadUsersSuccess({ users });
-
-    actions$ = hot('-a', { a: action });
-    const response = cold('-b|', { b: users });
-    const expected = cold('--c', { c: outcome });
-
-    usersService.getAll.and.returnValue(response);
-
-    expect(effects.loadUsers$).toBeObservable(expected);
-  });
-
-  it('should handle load users failure', () => {
-    const action = UsersActions.loadUsers();
-    const error = new Error('Failed to load');
-    const outcome = UsersActions.loadUsersFailure({ error: error.message });
-
-    actions$ = hot('-a', { a: action });
-    const response = cold('-#|', {}, error);
-    const expected = cold('--c', { c: outcome });
-
-    usersService.getAll.and.returnValue(response);
-
-    expect(effects.loadUsers$).toBeObservable(expected);
-  });
-});
-```
-
-## Testing Guards
-
-```typescript
-import { TestBed } from '@angular/core/testing';
-import { Router } from '@angular/router';
-import { authGuard } from './auth.guard';
-import { AuthService } from './auth.service';
-
-describe('authGuard', () => {
-  let authService: jasmine.SpyObj<AuthService>;
-  let router: jasmine.SpyObj<Router>;
-
-  beforeEach(() => {
-    const authServiceSpy = jasmine.createSpyObj('AuthService', ['isAuthenticated']);
-    const routerSpy = jasmine.createSpyObj('Router', ['createUrlTree']);
-
-    TestBed.configureTestingModule({
-      providers: [
-        { provide: AuthService, useValue: authServiceSpy },
-        { provide: Router, useValue: routerSpy }
-      ]
-    });
-
-    authService = TestBed.inject(AuthService) as jasmine.SpyObj<AuthService>;
-    router = TestBed.inject(Router) as jasmine.SpyObj<Router>;
-  });
-
-  it('should allow access when authenticated', () => {
-    authService.isAuthenticated.and.returnValue(true);
-
-    const result = TestBed.runInInjectionContext(() =>
-      authGuard({} as any, {} as any)
-    );
-
-    expect(result).toBe(true);
-  });
-
-  it('should redirect when not authenticated', () => {
-    authService.isAuthenticated.and.returnValue(false);
-    const urlTree = {} as any;
-    router.createUrlTree.and.returnValue(urlTree);
-
-    const result = TestBed.runInInjectionContext(() =>
-      authGuard({} as any, { url: '/protected' } as any)
-    );
-
-    expect(result).toBe(urlTree);
-    expect(router.createUrlTree).toHaveBeenCalledWith(
-      ['/login'],
-      { queryParams: { returnUrl: '/protected' } }
-    );
-  });
-});
-```
-
-## Quick Reference
-
-| Test Type | Key Tools |
-|-----------|-----------|
-| Component | `TestBed`, `ComponentFixture`, `detectChanges()` |
-| Service | `HttpClientTestingModule`, `HttpTestingController` |
-| RxJS | `TestScheduler`, marble diagrams |
-| NgRx Store | `provideMockStore`, `MockStore` |
-| Effects | `provideMockActions`, jasmine-marbles |
-| Guards | `TestBed.runInInjectionContext()` |
-| Signals | Direct value checks with `()` |
-| Spies | `jasmine.createSpyObj()`, `spyOn()` |

package/skills/api-designer/SKILL.md

@@ -1,217 +0,0 @@
----
-name: api-designer
-description: Use when designing REST or GraphQL APIs, creating OpenAPI specifications, or planning API architecture. Invoke for resource modeling, versioning strategies, pagination patterns, error handling standards.
-license: MIT
-metadata:
-  author: https://github.com/Jeffallan
-  version: "1.1.0"
-  domain: api-architecture
-  triggers: API design, REST API, OpenAPI, API specification, API architecture, resource modeling, API versioning, GraphQL schema, API documentation
-  role: architect
-  scope: design
-  output-format: specification
-  related-skills: graphql-architect, fastapi-expert, nestjs-expert, spring-boot-engineer, security-reviewer
----
-
-# API Designer
-
-Senior API architect specializing in REST and GraphQL APIs with comprehensive OpenAPI 3.1 specifications.
-
-## Core Workflow
-
-1. **Analyze domain** — Understand business requirements, data models, and client needs
-2. **Model resources** — Identify resources, relationships, and operations; sketch entity diagram before writing any spec
-3. **Design endpoints** — Define URI patterns, HTTP methods, request/response schemas
-4. **Specify contract** — Create OpenAPI 3.1 spec; validate before proceeding: `npx @redocly/cli lint openapi.yaml`
-5. **Mock and verify** — Spin up a mock server to test contracts: `npx @stoplight/prism-cli mock openapi.yaml`
-6. **Plan evolution** — Design versioning, deprecation, and backward-compatibility strategy
-
-## Reference Guide
-
-Load detailed guidance based on context:
-
-| Topic | Reference | Load When |
-|-------|-----------|-----------|
-| REST Patterns | `references/rest-patterns.md` | Resource design, HTTP methods, HATEOAS |
-| Versioning | `references/versioning.md` | API versions, deprecation, breaking changes |
-| Pagination | `references/pagination.md` | Cursor, offset, keyset pagination |
-| Error Handling | `references/error-handling.md` | Error responses, RFC 7807, status codes |
-| OpenAPI | `references/openapi.md` | OpenAPI 3.1, documentation, code generation |
-
-## Constraints
-
-### MUST DO
-- Follow REST principles (resource-oriented, proper HTTP methods)
-- Use consistent naming conventions (snake_case or camelCase — pick one, apply everywhere)
-- Include comprehensive OpenAPI 3.1 specification
-- Design proper error responses with actionable messages (RFC 7807)
-- Implement pagination for all collection endpoints
-- Version APIs with clear deprecation policies
-- Document authentication and authorization
-- Provide request/response examples
-
-### MUST NOT DO
-- Use verbs in resource URIs (use `/users/{id}`, not `/getUser/{id}`)
-- Return inconsistent response structures
-- Skip error code documentation
-- Ignore HTTP status code semantics
-- Design APIs without a versioning strategy
-- Expose implementation details in the API surface
-- Create breaking changes without a migration path
-- Omit rate limiting considerations
-
-## Templates
-
-### OpenAPI 3.1 Resource Endpoint (copy-paste starter)
-
-```yaml
-openapi: "3.1.0"
-info:
-  title: Example API
-  version: "1.1.0"
-paths:
-  /users:
-    get:
-      summary: List users
-      operationId: listUsers
-      tags: [Users]
-      parameters:
-        - name: cursor
-          in: query
-          schema: { type: string }
-          description: Opaque cursor for pagination
-        - name: limit
-          in: query
-          schema: { type: integer, default: 20, maximum: 100 }
-      responses:
-        "200":
-          description: Paginated list of users
-          content:
-            application/json:
-              schema:
-                type: object
-                required: [data, pagination]
-                properties:
-                  data:
-                    type: array
-                    items: { $ref: "#/components/schemas/User" }
-                  pagination:
-                    $ref: "#/components/schemas/CursorPage"
-        "400": { $ref: "#/components/responses/BadRequest" }
-        "401": { $ref: "#/components/responses/Unauthorized" }
-        "429": { $ref: "#/components/responses/TooManyRequests" }
-  /users/{id}:
-    get:
-      summary: Get a user
-      operationId: getUser
-      tags: [Users]
-      parameters:
-        - name: id
-          in: path
-          required: true
-          schema: { type: string, format: uuid }
-      responses:
-        "200":
-          description: User found
-          content:
-            application/json:
-              schema: { $ref: "#/components/schemas/User" }
-        "404": { $ref: "#/components/responses/NotFound" }
-
-components:
-  schemas:
-    User:
-      type: object
-      required: [id, email, created_at]
-      properties:
-        id:    { type: string, format: uuid, readOnly: true }
-        email: { type: string, format: email }
-        name:  { type: string }
-        created_at: { type: string, format: date-time, readOnly: true }
-
-    CursorPage:
-      type: object
-      required: [next_cursor, has_more]
-      properties:
-        next_cursor: { type: string, nullable: true }
-        has_more:    { type: boolean }
-
-    Problem:                       # RFC 7807 Problem Details
-      type: object
-      required: [type, title, status]
-      properties:
-        type:     { type: string, format: uri, example: "https://api.example.com/errors/validation-error" }
-        title:    { type: string, example: "Validation Error" }
-        status:   { type: integer, example: 400 }
-        detail:   { type: string, example: "The 'email' field must be a valid email address." }
-        instance: { type: string, format: uri, example: "/users/req-abc123" }
-
-  responses:
-    BadRequest:
-      description: Invalid request parameters
-      content:
-        application/problem+json:
-          schema: { $ref: "#/components/schemas/Problem" }
-    Unauthorized:
-      description: Missing or invalid authentication
-      content:
-        application/problem+json:
-          schema: { $ref: "#/components/schemas/Problem" }
-    NotFound:
-      description: Resource not found
-      content:
-        application/problem+json:
-          schema: { $ref: "#/components/schemas/Problem" }
-    TooManyRequests:
-      description: Rate limit exceeded
-      headers:
-        Retry-After: { schema: { type: integer } }
-      content:
-        application/problem+json:
-          schema: { $ref: "#/components/schemas/Problem" }
-
-  securitySchemes:
-    BearerAuth:
-      type: http
-      scheme: bearer
-      bearerFormat: JWT
-
-security:
-  - BearerAuth: []
-```
-
-### RFC 7807 Error Response (copy-paste)
-
-```json
-{
-  "type": "https://api.example.com/errors/validation-error",
-  "title": "Validation Error",
-  "status": 422,
-  "detail": "The 'email' field must be a valid email address.",
-  "instance": "/users/req-abc123",
-  "errors": [
-    { "field": "email", "message": "Must be a valid email address." }
-  ]
-}
-```
-
-- Always use `Content-Type: application/problem+json` for error responses.
-- `type` must be a stable, documented URI — never a generic string.
-- `detail` must be human-readable and actionable.
-- Extend with `errors[]` for field-level validation failures.
-
-## Output Checklist
-
-When delivering an API design, provide:
-1. Resource model and relationships (diagram or table)
-2. Endpoint specifications with URIs and HTTP methods
-3. OpenAPI 3.1 specification (YAML)
-4. Authentication and authorization flows
-5. Error response catalog (all 4xx/5xx with `type` URIs)
-6. Pagination and filtering patterns
-7. Versioning and deprecation strategy
-8. Validation result: `npx @redocly/cli lint openapi.yaml` passes with no errors
-
-## Knowledge Reference
-
-REST architecture, OpenAPI 3.1, GraphQL, HTTP semantics, JSON:API, HATEOAS, OAuth 2.0, JWT, RFC 7807 Problem Details, API versioning patterns, pagination strategies, rate limiting, webhook design, SDK generation