@bradtaylorsf/alpha-loop 1.1.2 → 1.2.0

package/templates/skills/api-patterns/templates/express-router-template.ts

@@ -1,294 +0,0 @@
-/**
- * Express Router Template
- * Use this template for creating new resource routers
- */
-
-import { Router } from 'express';
-import { z } from 'zod';
-import { validateRequest } from '../middleware/validation';
-import { requireAuth } from '../middleware/auth';
-import { AppError } from '../utils/errors';
-
-const router = Router();
-
-// ============================================================================
-// Validation Schemas
-// ============================================================================
-
-const CreateSchema = z.object({
-  // Define your fields here
-  name: z.string().min(1).max(255),
-  description: z.string().optional()
-});
-
-const UpdateSchema = CreateSchema.partial();
-
-const QuerySchema = z.object({
-  page: z.coerce.number().int().min(1).default(1),
-  limit: z.coerce.number().int().min(1).max(100).default(20),
-  sortBy: z.enum(['createdAt', 'updatedAt', 'name']).default('createdAt'),
-  sortOrder: z.enum(['asc', 'desc']).default('desc')
-});
-
-// Type inference
-type CreateDto = z.infer<typeof CreateSchema>;
-type UpdateDto = z.infer<typeof UpdateSchema>;
-type QueryDto = z.infer<typeof QuerySchema>;
-
-// ============================================================================
-// Routes
-// ============================================================================
-
-/**
- * @openapi
- * /api/resources:
- *   get:
- *     summary: List all resources
- *     tags: [Resources]
- *     security:
- *       - bearerAuth: []
- *     parameters:
- *       - in: query
- *         name: page
- *         schema:
- *           type: integer
- *           minimum: 1
- *       - in: query
- *         name: limit
- *         schema:
- *           type: integer
- *           minimum: 1
- *           maximum: 100
- *     responses:
- *       200:
- *         description: List of resources
- */
-router.get(
-  '/',
-  requireAuth,
-  validateRequest(QuerySchema),
-  async (req, res, next) => {
-    try {
-      const query = req.body as QueryDto;
-      const { page, limit, sortBy, sortOrder } = query;
-      const offset = (page - 1) * limit;
-
-      // TODO: Replace with actual database query
-      const resources = [];
-      const total = 0;
-
-      res.json({
-        data: resources,
-        pagination: {
-          page,
-          limit,
-          total,
-          totalPages: Math.ceil(total / limit)
-        }
-      });
-    } catch (err) {
-      next(err);
-    }
-  }
-);
-
-/**
- * @openapi
- * /api/resources/{id}:
- *   get:
- *     summary: Get a single resource
- *     tags: [Resources]
- *     security:
- *       - bearerAuth: []
- *     parameters:
- *       - in: path
- *         name: id
- *         required: true
- *         schema:
- *           type: string
- *     responses:
- *       200:
- *         description: Resource found
- *       404:
- *         description: Resource not found
- */
-router.get('/:id', requireAuth, async (req, res, next) => {
-  try {
-    const { id } = req.params;
-
-    // TODO: Replace with actual database query
-    const resource = null;
-
-    if (!resource) {
-      throw new AppError('Resource not found', 404, 'RESOURCE_NOT_FOUND');
-    }
-
-    res.json({ data: resource });
-  } catch (err) {
-    next(err);
-  }
-});
-
-/**
- * @openapi
- * /api/resources:
- *   post:
- *     summary: Create a new resource
- *     tags: [Resources]
- *     security:
- *       - bearerAuth: []
- *     requestBody:
- *       required: true
- *       content:
- *         application/json:
- *           schema:
- *             type: object
- *             required:
- *               - name
- *             properties:
- *               name:
- *                 type: string
- *               description:
- *                 type: string
- *     responses:
- *       201:
- *         description: Resource created
- */
-router.post(
-  '/',
-  requireAuth,
-  validateRequest(CreateSchema),
-  async (req, res, next) => {
-    try {
-      const data = req.body as CreateDto;
-      const userId = (req as any).userId;
-
-      // TODO: Replace with actual database insert
-      const resource = {
-        id: 'generated-id',
-        ...data,
-        userId,
-        createdAt: new Date().toISOString(),
-        updatedAt: new Date().toISOString()
-      };
-
-      res.status(201).json({ data: resource });
-    } catch (err) {
-      next(err);
-    }
-  }
-);
-
-/**
- * @openapi
- * /api/resources/{id}:
- *   put:
- *     summary: Update a resource
- *     tags: [Resources]
- *     security:
- *       - bearerAuth: []
- *     parameters:
- *       - in: path
- *         name: id
- *         required: true
- *         schema:
- *           type: string
- *     requestBody:
- *       required: true
- *       content:
- *         application/json:
- *           schema:
- *             type: object
- *             properties:
- *               name:
- *                 type: string
- *               description:
- *                 type: string
- *     responses:
- *       200:
- *         description: Resource updated
- *       404:
- *         description: Resource not found
- */
-router.put(
-  '/:id',
-  requireAuth,
-  validateRequest(UpdateSchema),
-  async (req, res, next) => {
-    try {
-      const { id } = req.params;
-      const data = req.body as UpdateDto;
-      const userId = (req as any).userId;
-
-      // TODO: Replace with actual database query
-      const resource = null;
-
-      if (!resource) {
-        throw new AppError('Resource not found', 404, 'RESOURCE_NOT_FOUND');
-      }
-
-      // Check authorization
-      if ((resource as any).userId !== userId) {
-        throw new AppError('Forbidden', 403, 'FORBIDDEN');
-      }
-
-      // TODO: Replace with actual database update
-      const updated = {
-        ...resource,
-        ...data,
-        updatedAt: new Date().toISOString()
-      };
-
-      res.json({ data: updated });
-    } catch (err) {
-      next(err);
-    }
-  }
-);
-
-/**
- * @openapi
- * /api/resources/{id}:
- *   delete:
- *     summary: Delete a resource
- *     tags: [Resources]
- *     security:
- *       - bearerAuth: []
- *     parameters:
- *       - in: path
- *         name: id
- *         required: true
- *         schema:
- *           type: string
- *     responses:
- *       204:
- *         description: Resource deleted
- *       404:
- *         description: Resource not found
- */
-router.delete('/:id', requireAuth, async (req, res, next) => {
-  try {
-    const { id } = req.params;
-    const userId = (req as any).userId;
-
-    // TODO: Replace with actual database query
-    const resource = null;
-
-    if (!resource) {
-      throw new AppError('Resource not found', 404, 'RESOURCE_NOT_FOUND');
-    }
-
-    // Check authorization
-    if ((resource as any).userId !== userId) {
-      throw new AppError('Forbidden', 403, 'FORBIDDEN');
-    }
-
-    // TODO: Replace with actual database delete
-
-    res.status(204).send();
-  } catch (err) {
-    next(err);
-  }
-});
-
-export default router;

package/templates/skills/jest-mock-patterns/SKILL.md

@@ -1,397 +0,0 @@
----
-name: jest-mock-patterns
-description: Common Jest mocking gotchas and solutions. Document common Jest mocking pitfalls including resetMocks behavior, module mocking order, and system global mocking.
----
-
-# Jest Mock Patterns Skill
-
-Comprehensive guide to Jest mocking patterns, common gotchas, and solutions.
-
-## Configuration Gotchas
-
-### resetMocks vs clearMocks vs restoreMocks
-
-| Option | Clears call history | Clears return values | Restores original |
-|--------|--------------------|-----------------------|-------------------|
-| `clearMocks` | Yes | No | No |
-| `resetMocks` | Yes | **Yes** | No |
-| `restoreMocks` | Yes | Yes | Yes |
-
-**CRITICAL**: AlphaCoder uses `resetMocks: true` in Jest config!
-
-### The resetMocks: true Gotcha
-
-**Problem:** Mock return values are cleared between tests.
-
-```typescript
-// ❌ WRONG - Return value lost after first test
-const mockGetSession = jest.fn().mockReturnValue({ id: 1, status: 'active' });
-jest.mock('./session-manager', () => ({ getSession: mockGetSession }));
-
-describe('Session tests', () => {
-  it('test 1', () => {
-    expect(mockGetSession()).toEqual({ id: 1, status: 'active' }); // PASS
-  });
-
-  it('test 2', () => {
-    // mockGetSession now returns undefined due to resetMocks!
-    expect(mockGetSession()).toEqual({ id: 1, status: 'active' }); // FAIL
-  });
-});
-```
-
-**Solution:** Re-set mock return values in `beforeEach`:
-
-```typescript
-// ✅ CORRECT - Reset return values each test
-import { getSession } from './session-manager';
-jest.mock('./session-manager');
-
-const mockedGetSession = getSession as jest.Mock;
-
-describe('Session tests', () => {
-  beforeEach(() => {
-    mockedGetSession.mockReturnValue({ id: 1, status: 'active' });
-  });
-
-  it('test 1', () => {
-    expect(mockedGetSession()).toEqual({ id: 1, status: 'active' }); // PASS
-  });
-
-  it('test 2', () => {
-    expect(mockedGetSession()).toEqual({ id: 1, status: 'active' }); // PASS
-  });
-});
-```
-
-**Alternative:** Mock factory function (called for each test):
-
-```typescript
-// ✅ ALSO CORRECT - Factory function approach
-jest.mock('./session-manager', () => ({
-  getSession: jest.fn(() => ({ id: 1, status: 'active' })),
-}));
-```
-
-## Module Mocking Order
-
-### Mocks MUST Be Before Imports
-
-Jest hoists `jest.mock()` calls, but the mock factory runs at import time.
-
-```typescript
-// ✅ CORRECT ORDER
-jest.mock('./database');
-import { getDatabase } from './database'; // Receives mocked version
-
-// ❌ WRONG ORDER - Import already resolved
-import { getDatabase } from './database'; // Gets real version
-jest.mock('./database'); // Too late!
-```
-
-### Dynamic Imports with Mocks
-
-For complex cases, use dynamic imports:
-
-```typescript
-jest.mock('./database');
-
-describe('tests', () => {
-  let myModule: typeof import('./my-module');
-
-  beforeEach(async () => {
-    // Fresh import each test
-    myModule = await import('./my-module');
-  });
-});
-```
-
-## Mocking System Globals
-
-### process.kill for PID Checking
-
-Standard pattern for testing code that checks if processes are alive:
-
-```typescript
-// Create test helpers
-const originalKill = process.kill;
-const deadPids = new Set<number>();
-
-beforeEach(() => {
-  deadPids.clear();
-  (process.kill as jest.Mock) = jest.fn((pid: number, signal?: number) => {
-    // Signal 0 = check if process exists (without killing)
-    if (signal === 0 && deadPids.has(pid)) {
-      const error = new Error('ESRCH: no such process');
-      (error as NodeJS.ErrnoException).code = 'ESRCH';
-      throw error;
-    }
-    return true;
-  });
-});
-
-afterEach(() => {
-  process.kill = originalKill;
-});
-
-// Usage in tests:
-describe('Process detection', () => {
-  it('returns true for alive process', () => {
-    expect(isProcessAlive(12345)).toBe(true);
-  });
-
-  it('returns false for dead process', () => {
-    deadPids.add(12345);
-    expect(isProcessAlive(12345)).toBe(false);
-  });
-});
-```
-
-### process.pid
-
-```typescript
-const originalPid = process.pid;
-
-beforeEach(() => {
-  Object.defineProperty(process, 'pid', { value: 99999, writable: true });
-});
-
-afterEach(() => {
-  Object.defineProperty(process, 'pid', { value: originalPid, writable: true });
-});
-```
-
-### Date/Time Mocking
-
-```typescript
-describe('Time-sensitive tests', () => {
-  beforeEach(() => {
-    jest.useFakeTimers();
-    jest.setSystemTime(new Date('2025-01-01T00:00:00Z'));
-  });
-
-  afterEach(() => {
-    jest.useRealTimers();
-  });
-
-  it('uses mocked time', () => {
-    expect(new Date().toISOString()).toBe('2025-01-01T00:00:00.000Z');
-  });
-
-  it('can advance time', () => {
-    jest.advanceTimersByTime(60000); // 1 minute
-    expect(new Date().toISOString()).toBe('2025-01-01T00:01:00.000Z');
-  });
-});
-```
-
-### setTimeout/setInterval
-
-```typescript
-beforeEach(() => {
-  jest.useFakeTimers();
-});
-
-afterEach(() => {
-  jest.useRealTimers();
-});
-
-it('handles delayed callback', () => {
-  const callback = jest.fn();
-  setTimeout(callback, 1000);
-
-  expect(callback).not.toHaveBeenCalled();
-
-  jest.advanceTimersByTime(1000);
-
-  expect(callback).toHaveBeenCalledTimes(1);
-});
-```
-
-## Mocking Expensive Infrastructure
-
-### Claude CLI / AgentSession
-
-Avoid spawning real Claude processes ($$$):
-
-```typescript
-jest.mock('../../src/server/agent.js', () => ({
-  AgentSession: jest.fn().mockImplementation(() => ({
-    run: jest.fn().mockResolvedValue(undefined),
-    on: jest.fn(),
-    stop: jest.fn(),
-    emit: jest.fn(),
-  })),
-}));
-```
-
-### Session Manager
-
-```typescript
-const mockGetActiveSession = jest.fn();
-const mockStartSession = jest.fn();
-const mockStopSession = jest.fn();
-
-jest.mock('../../src/server/session-manager.js', () => ({
-  getActiveSession: mockGetActiveSession,
-  startSession: mockStartSession,
-  stopSession: mockStopSession,
-  getActiveSessionCount: jest.fn().mockReturnValue(0),
-}));
-
-// In beforeEach, reset return values:
-beforeEach(() => {
-  mockGetActiveSession.mockReturnValue(null);
-  mockStartSession.mockResolvedValue({ on: jest.fn() });
-});
-```
-
-### WebSocket Broadcasting
-
-```typescript
-const mockBroadcast = jest.fn();
-jest.mock('../../src/server/websocket-broadcaster.js', () => ({
-  broadcast: mockBroadcast,
-}));
-
-// Verify broadcasts in tests:
-expect(mockBroadcast).toHaveBeenCalledWith({
-  type: 'session_started',
-  payload: expect.objectContaining({
-    projectId: 1,
-    sessionType: 'coding',
-  }),
-});
-```
-
-### Database (In-Memory SQLite)
-
-```typescript
-import Database from 'better-sqlite3';
-
-let testDb: Database.Database;
-
-beforeAll(() => {
-  testDb = new Database(':memory:');
-  testDb.exec(`
-    CREATE TABLE sessions (
-      id INTEGER PRIMARY KEY,
-      status TEXT DEFAULT 'pending'
-    );
-  `);
-});
-
-afterAll(() => {
-  testDb.close();
-});
-
-// Mock getDatabase to return test db
-jest.mock('../../src/server/database.js', () => ({
-  getDatabase: () => testDb,
-}));
-```
-
-## Spy vs Mock
-
-### When to Use Spies
-
-Spies observe calls to real implementations:
-
-```typescript
-// Spy on existing method - real implementation runs
-const consoleSpy = jest.spyOn(console, 'log');
-
-doSomething(); // console.log actually runs
-
-expect(consoleSpy).toHaveBeenCalledWith('expected message');
-
-consoleSpy.mockRestore();
-```
-
-### When to Use Mocks
-
-Mocks replace implementations entirely:
-
-```typescript
-// Mock replaces implementation
-jest.spyOn(console, 'log').mockImplementation(() => {});
-
-doSomething(); // console.log is silenced
-
-expect(console.log).toHaveBeenCalled();
-```
-
-## Common Patterns
-
-### Testing Async Code
-
-```typescript
-it('handles async operations', async () => {
-  mockFetch.mockResolvedValue({ data: 'result' });
-
-  const result = await fetchData();
-
-  expect(result).toEqual({ data: 'result' });
-});
-
-it('handles async errors', async () => {
-  mockFetch.mockRejectedValue(new Error('Network error'));
-
-  await expect(fetchData()).rejects.toThrow('Network error');
-});
-```
-
-### Testing Event Emitters
-
-```typescript
-it('emits events correctly', () => {
-  const mockCallback = jest.fn();
-  emitter.on('event', mockCallback);
-
-  emitter.emit('event', { data: 'test' });
-
-  expect(mockCallback).toHaveBeenCalledWith({ data: 'test' });
-});
-```
-
-### Partial Mocking
-
-Mock only specific exports:
-
-```typescript
-jest.mock('./utils', () => ({
-  ...jest.requireActual('./utils'), // Keep real implementations
-  expensiveFunction: jest.fn(),      // Mock only this one
-}));
-```
-
-## Troubleshooting
-
-### Mock Not Being Applied
-
-1. Check mock order (before imports)
-2. Check mock path matches import path exactly
-3. Check for `.js` extension in ESM projects
-
-### Mock Return Value Undefined
-
-1. Check if `resetMocks: true` in Jest config
-2. Add return value in `beforeEach`
-
-### Tests Pass Individually, Fail Together
-
-1. Mock state leaking between tests
-2. Missing cleanup in `afterEach`
-3. Shared mutable state
-
-### Timeout Errors
-
-1. Missing `await` on async operations
-2. Unresolved promises in mocked functions
-3. `useFakeTimers()` blocking real timers
-
-## Reference
-
-- Jest Mocking: https://jestjs.io/docs/mock-functions
-- Jest Timer Mocks: https://jestjs.io/docs/timer-mocks
-- Jest ES6 Mocks: https://jestjs.io/docs/es6-class-mocks