autoworkflow 3.1.5 → 3.5.0

package/.claude/skills/playwright.md

@@ -0,0 +1,371 @@
+# Playwright Skill
+
+## Test Structure
+\`\`\`typescript
+import { test, expect } from '@playwright/test';
+
+test.describe('Authentication', () => {
+  test.beforeEach(async ({ page }) => {
+    await page.goto('/login');
+  });
+
+  test('should login successfully', async ({ page }) => {
+    // Use accessible selectors (recommended)
+    await page.getByLabel('Email').fill('test@example.com');
+    await page.getByLabel('Password').fill('password123');
+    await page.getByRole('button', { name: 'Sign in' }).click();
+
+    // Web-first assertions (auto-wait)
+    await expect(page).toHaveURL('/dashboard');
+    await expect(page.getByRole('heading', { name: 'Dashboard' })).toBeVisible();
+  });
+
+  test('should show error for invalid credentials', async ({ page }) => {
+    await page.getByLabel('Email').fill('wrong@example.com');
+    await page.getByLabel('Password').fill('wrongpassword');
+    await page.getByRole('button', { name: 'Sign in' }).click();
+
+    await expect(page.getByText('Invalid credentials')).toBeVisible();
+    await expect(page).toHaveURL('/login');
+  });
+});
+\`\`\`
+
+## Locators (Selectors)
+\`\`\`typescript
+// Recommended: Accessible selectors
+page.getByRole('button', { name: 'Submit' });
+page.getByRole('textbox', { name: 'Email' });
+page.getByRole('checkbox', { name: 'Remember me' });
+page.getByRole('link', { name: 'Sign up' });
+page.getByRole('heading', { name: 'Welcome', level: 1 });
+
+page.getByLabel('Email');           // Form labels
+page.getByPlaceholder('Enter email');
+page.getByText('Submit');           // Exact text
+page.getByText(/submit/i);          // Regex
+page.getByAltText('Logo');          // Image alt
+page.getByTitle('Close');           // Title attribute
+
+// Test IDs (when accessibility isn't possible)
+page.getByTestId('submit-button');  // data-testid="submit-button"
+
+// CSS/XPath (use sparingly)
+page.locator('.submit-btn');
+page.locator('#email');
+page.locator('css=button.primary');
+page.locator('xpath=//button[@type="submit"]');
+
+// Chaining and filtering
+page.getByRole('listitem').filter({ hasText: 'Product 1' });
+page.getByRole('listitem').filter({ has: page.getByRole('button') });
+page.locator('article').filter({ hasText: 'Playwright' }).getByRole('link');
+
+// Nth element
+page.getByRole('listitem').nth(2);
+page.getByRole('listitem').first();
+page.getByRole('listitem').last();
+\`\`\`
+
+## Actions
+\`\`\`typescript
+// Click actions
+await page.getByRole('button').click();
+await page.getByRole('button').dblclick();
+await page.getByRole('button').click({ button: 'right' });
+await page.getByRole('button').click({ modifiers: ['Shift'] });
+await page.getByRole('link').click({ force: true }); // Skip actionability checks
+
+// Input actions
+await page.getByLabel('Name').fill('John Doe');
+await page.getByLabel('Name').clear();
+await page.getByLabel('Name').type('John', { delay: 100 }); // Simulate typing
+await page.getByLabel('Name').press('Enter');
+await page.getByLabel('Name').pressSequentially('Hello'); // Key by key
+
+// Select and checkbox
+await page.getByLabel('Country').selectOption('US');
+await page.getByLabel('Country').selectOption({ label: 'United States' });
+await page.getByRole('checkbox').check();
+await page.getByRole('checkbox').uncheck();
+await page.getByRole('radio', { name: 'Option 1' }).check();
+
+// File upload
+await page.getByLabel('Upload').setInputFiles('file.pdf');
+await page.getByLabel('Upload').setInputFiles(['file1.pdf', 'file2.pdf']);
+
+// Drag and drop
+await page.getByText('Drag me').dragTo(page.getByText('Drop here'));
+
+// Hover
+await page.getByRole('button').hover();
+
+// Focus
+await page.getByLabel('Email').focus();
+\`\`\`
+
+## Assertions
+\`\`\`typescript
+// Page assertions
+await expect(page).toHaveURL('/dashboard');
+await expect(page).toHaveURL(/dashboard/);
+await expect(page).toHaveTitle('Dashboard');
+
+// Element assertions (auto-wait)
+await expect(locator).toBeVisible();
+await expect(locator).toBeHidden();
+await expect(locator).toBeEnabled();
+await expect(locator).toBeDisabled();
+await expect(locator).toBeChecked();
+await expect(locator).toBeFocused();
+await expect(locator).toBeEditable();
+
+// Content assertions
+await expect(locator).toHaveText('Hello');
+await expect(locator).toHaveText(/hello/i);
+await expect(locator).toContainText('Hello');
+await expect(locator).toHaveValue('input value');
+await expect(locator).toHaveAttribute('href', '/home');
+await expect(locator).toHaveClass(/active/);
+await expect(locator).toHaveCSS('color', 'rgb(0, 0, 0)');
+await expect(locator).toHaveCount(5);
+
+// Negation
+await expect(locator).not.toBeVisible();
+
+// Soft assertions (don't stop test on failure)
+await expect.soft(locator).toHaveText('Hello');
+\`\`\`
+
+## Page Object Model
+\`\`\`typescript
+// pages/LoginPage.ts
+import { Page, Locator, expect } from '@playwright/test';
+
+export class LoginPage {
+  readonly page: Page;
+  readonly emailInput: Locator;
+  readonly passwordInput: Locator;
+  readonly submitButton: Locator;
+  readonly errorMessage: Locator;
+
+  constructor(page: Page) {
+    this.page = page;
+    this.emailInput = page.getByLabel('Email');
+    this.passwordInput = page.getByLabel('Password');
+    this.submitButton = page.getByRole('button', { name: 'Sign in' });
+    this.errorMessage = page.getByRole('alert');
+  }
+
+  async goto() {
+    await this.page.goto('/login');
+  }
+
+  async login(email: string, password: string) {
+    await this.emailInput.fill(email);
+    await this.passwordInput.fill(password);
+    await this.submitButton.click();
+  }
+
+  async expectError(message: string) {
+    await expect(this.errorMessage).toHaveText(message);
+  }
+}
+
+// tests/login.spec.ts
+import { test, expect } from '@playwright/test';
+import { LoginPage } from '../pages/LoginPage';
+
+test('should login', async ({ page }) => {
+  const loginPage = new LoginPage(page);
+  await loginPage.goto();
+  await loginPage.login('user@example.com', 'password123');
+  await expect(page).toHaveURL('/dashboard');
+});
+\`\`\`
+
+## Fixtures
+\`\`\`typescript
+// fixtures.ts
+import { test as base, expect } from '@playwright/test';
+import { LoginPage } from './pages/LoginPage';
+import { DashboardPage } from './pages/DashboardPage';
+
+type MyFixtures = {
+  loginPage: LoginPage;
+  dashboardPage: DashboardPage;
+  authenticatedPage: void;
+};
+
+export const test = base.extend<MyFixtures>({
+  loginPage: async ({ page }, use) => {
+    const loginPage = new LoginPage(page);
+    await use(loginPage);
+  },
+
+  dashboardPage: async ({ page }, use) => {
+    await use(new DashboardPage(page));
+  },
+
+  // Auto-login fixture
+  authenticatedPage: async ({ page }, use) => {
+    // Set auth cookies/storage
+    await page.context().addCookies([{
+      name: 'auth-token',
+      value: 'test-token',
+      domain: 'localhost',
+      path: '/',
+    }]);
+    await use();
+  },
+});
+
+// Usage in tests
+test('should show dashboard', async ({ dashboardPage, authenticatedPage }) => {
+  await dashboardPage.goto();
+  await dashboardPage.expectWelcomeMessage();
+});
+\`\`\`
+
+## API Testing
+\`\`\`typescript
+import { test, expect } from '@playwright/test';
+
+test('API: should create user', async ({ request }) => {
+  const response = await request.post('/api/users', {
+    data: { email: 'test@example.com', name: 'Test' },
+  });
+
+  expect(response.ok()).toBeTruthy();
+  expect(response.status()).toBe(201);
+
+  const user = await response.json();
+  expect(user).toMatchObject({
+    email: 'test@example.com',
+    name: 'Test',
+  });
+});
+
+test('API: should handle authentication', async ({ request }) => {
+  // Login and get token
+  const loginResponse = await request.post('/api/login', {
+    data: { email: 'test@example.com', password: 'password123' },
+  });
+  const { token } = await loginResponse.json();
+
+  // Use token in subsequent requests
+  const response = await request.get('/api/profile', {
+    headers: { Authorization: \`Bearer \${token}\` },
+  });
+
+  expect(response.ok()).toBeTruthy();
+});
+\`\`\`
+
+## Network Mocking
+\`\`\`typescript
+test('should mock API response', async ({ page }) => {
+  // Mock API response
+  await page.route('/api/users', async (route) => {
+    await route.fulfill({
+      status: 200,
+      contentType: 'application/json',
+      body: JSON.stringify([{ id: 1, name: 'Mocked User' }]),
+    });
+  });
+
+  await page.goto('/users');
+  await expect(page.getByText('Mocked User')).toBeVisible();
+});
+
+test('should intercept and modify response', async ({ page }) => {
+  await page.route('/api/users', async (route) => {
+    const response = await route.fetch();
+    const json = await response.json();
+    json.push({ id: 999, name: 'Injected User' });
+    await route.fulfill({ response, json });
+  });
+});
+
+test('should abort request', async ({ page }) => {
+  await page.route('**/*.{png,jpg,jpeg}', route => route.abort());
+  await page.goto('/page'); // Images won't load
+});
+
+// Wait for specific request
+const responsePromise = page.waitForResponse('/api/users');
+await page.getByRole('button', { name: 'Load' }).click();
+const response = await responsePromise;
+\`\`\`
+
+## Visual Testing
+\`\`\`typescript
+test('should match screenshot', async ({ page }) => {
+  await page.goto('/');
+
+  // Full page screenshot
+  await expect(page).toHaveScreenshot('homepage.png');
+
+  // Element screenshot
+  await expect(page.getByRole('main')).toHaveScreenshot('main-content.png');
+
+  // With options
+  await expect(page).toHaveScreenshot('homepage.png', {
+    maxDiffPixels: 100,
+    threshold: 0.2,
+    animations: 'disabled',
+  });
+});
+
+// Update screenshots: npx playwright test --update-snapshots
+\`\`\`
+
+## Configuration (playwright.config.ts)
+\`\`\`typescript
+import { defineConfig, devices } from '@playwright/test';
+
+export default defineConfig({
+  testDir: './tests',
+  fullyParallel: true,
+  forbidOnly: !!process.env.CI,
+  retries: process.env.CI ? 2 : 0,
+  workers: process.env.CI ? 1 : undefined,
+  reporter: [['html'], ['list']],
+
+  use: {
+    baseURL: 'http://localhost:3000',
+    trace: 'on-first-retry',
+    screenshot: 'only-on-failure',
+    video: 'on-first-retry',
+  },
+
+  projects: [
+    { name: 'chromium', use: { ...devices['Desktop Chrome'] } },
+    { name: 'firefox', use: { ...devices['Desktop Firefox'] } },
+    { name: 'webkit', use: { ...devices['Desktop Safari'] } },
+    { name: 'Mobile Chrome', use: { ...devices['Pixel 5'] } },
+  ],
+
+  webServer: {
+    command: 'npm run dev',
+    url: 'http://localhost:3000',
+    reuseExistingServer: !process.env.CI,
+  },
+});
+\`\`\`
+
+## ❌ DON'T
+- Use hard-coded waits (\`page.waitForTimeout\`)
+- Use CSS selectors when accessible selectors work
+- Test implementation details
+- Share state between tests
+- Forget to handle dynamic content
+
+## ✅ DO
+- Use web-first assertions (auto-wait)
+- Use accessible selectors (getByRole, getByLabel)
+- Use Page Object Model for large apps
+- Run tests in parallel
+- Use fixtures for shared setup
+- Use API testing for backend validation
+- Use trace viewer for debugging

package/.claude/skills/postgresql.md

@@ -0,0 +1,257 @@
+# PostgreSQL Skill
+
+## Schema Design
+\`\`\`sql
+-- Table with constraints
+CREATE TABLE users (
+  id UUID PRIMARY KEY DEFAULT gen_random_uuid(),
+  email VARCHAR(255) NOT NULL UNIQUE,
+  name VARCHAR(100) NOT NULL,
+  password_hash VARCHAR(255) NOT NULL,
+  role VARCHAR(20) DEFAULT 'user' CHECK (role IN ('user', 'admin', 'moderator')),
+  settings JSONB DEFAULT '{}',
+  created_at TIMESTAMPTZ DEFAULT NOW(),
+  updated_at TIMESTAMPTZ DEFAULT NOW(),
+  deleted_at TIMESTAMPTZ
+);
+
+-- Foreign key with cascade
+CREATE TABLE posts (
+  id UUID PRIMARY KEY DEFAULT gen_random_uuid(),
+  title VARCHAR(255) NOT NULL,
+  content TEXT,
+  published BOOLEAN DEFAULT FALSE,
+  author_id UUID NOT NULL REFERENCES users(id) ON DELETE CASCADE,
+  created_at TIMESTAMPTZ DEFAULT NOW()
+);
+
+-- Many-to-many junction table
+CREATE TABLE post_tags (
+  post_id UUID REFERENCES posts(id) ON DELETE CASCADE,
+  tag_id UUID REFERENCES tags(id) ON DELETE CASCADE,
+  PRIMARY KEY (post_id, tag_id)
+);
+
+-- Enum type (alternative to CHECK constraint)
+CREATE TYPE user_status AS ENUM ('active', 'inactive', 'suspended');
+ALTER TABLE users ADD COLUMN status user_status DEFAULT 'active';
+\`\`\`
+
+## Indexes
+\`\`\`sql
+-- B-tree index (default, good for equality and range)
+CREATE INDEX idx_users_email ON users(email);
+
+-- Compound index (order matters!)
+CREATE INDEX idx_posts_author_created ON posts(author_id, created_at DESC);
+
+-- Partial index (smaller, more efficient)
+CREATE INDEX idx_active_users ON users(email) WHERE deleted_at IS NULL;
+
+-- GIN index for JSONB
+CREATE INDEX idx_users_settings ON users USING GIN (settings);
+
+-- GIN index for full-text search
+CREATE INDEX idx_posts_content_search ON posts USING GIN (to_tsvector('english', content));
+
+-- Unique index with condition
+CREATE UNIQUE INDEX idx_unique_email_active ON users(email) WHERE deleted_at IS NULL;
+
+-- Covering index (includes non-key columns)
+CREATE INDEX idx_posts_author ON posts(author_id) INCLUDE (title, created_at);
+\`\`\`
+
+## Common Queries
+\`\`\`sql
+-- Pagination (offset-based)
+SELECT * FROM posts
+WHERE published = true
+ORDER BY created_at DESC
+LIMIT 20 OFFSET 40;
+
+-- Pagination (cursor-based, more efficient)
+SELECT * FROM posts
+WHERE published = true AND created_at < '2024-01-15T10:00:00Z'
+ORDER BY created_at DESC
+LIMIT 20;
+
+-- Upsert (INSERT ... ON CONFLICT)
+INSERT INTO users (email, name)
+VALUES ('user@example.com', 'John')
+ON CONFLICT (email)
+DO UPDATE SET name = EXCLUDED.name, updated_at = NOW();
+
+-- Returning inserted/updated data
+INSERT INTO users (email, name) VALUES ('new@example.com', 'New User')
+RETURNING id, email, created_at;
+
+-- Conditional update
+UPDATE users
+SET role = 'admin', updated_at = NOW()
+WHERE id = '...'
+RETURNING *;
+\`\`\`
+
+## JSONB Operations
+\`\`\`sql
+-- Query JSONB field
+SELECT * FROM users WHERE settings->>'theme' = 'dark';
+SELECT * FROM users WHERE settings @> '{"notifications": true}';
+
+-- Update JSONB field
+UPDATE users
+SET settings = settings || '{"theme": "light"}'
+WHERE id = '...';
+
+-- Remove JSONB key
+UPDATE users
+SET settings = settings - 'oldKey'
+WHERE id = '...';
+
+-- JSONB array operations
+SELECT * FROM users WHERE settings->'tags' ? 'premium';
+\`\`\`
+
+## CTEs (Common Table Expressions)
+\`\`\`sql
+-- Basic CTE
+WITH active_users AS (
+  SELECT * FROM users WHERE deleted_at IS NULL
+)
+SELECT u.*, COUNT(p.id) as post_count
+FROM active_users u
+LEFT JOIN posts p ON u.id = p.author_id
+GROUP BY u.id;
+
+-- Recursive CTE (hierarchical data)
+WITH RECURSIVE category_tree AS (
+  -- Base case
+  SELECT id, name, parent_id, 0 as depth
+  FROM categories
+  WHERE parent_id IS NULL
+
+  UNION ALL
+
+  -- Recursive case
+  SELECT c.id, c.name, c.parent_id, ct.depth + 1
+  FROM categories c
+  JOIN category_tree ct ON c.parent_id = ct.id
+)
+SELECT * FROM category_tree ORDER BY depth, name;
+
+-- CTE for data modification
+WITH deleted AS (
+  DELETE FROM users WHERE last_login < NOW() - INTERVAL '1 year'
+  RETURNING *
+)
+INSERT INTO deleted_users SELECT * FROM deleted;
+\`\`\`
+
+## Window Functions
+\`\`\`sql
+-- Row number for pagination
+SELECT *, ROW_NUMBER() OVER (ORDER BY created_at DESC) as row_num
+FROM posts;
+
+-- Running total
+SELECT
+  date,
+  amount,
+  SUM(amount) OVER (ORDER BY date) as running_total
+FROM transactions;
+
+-- Rank within groups
+SELECT
+  author_id,
+  title,
+  created_at,
+  ROW_NUMBER() OVER (PARTITION BY author_id ORDER BY created_at DESC) as post_rank
+FROM posts;
+
+-- Get previous/next values
+SELECT
+  title,
+  created_at,
+  LAG(title) OVER (ORDER BY created_at) as prev_title,
+  LEAD(title) OVER (ORDER BY created_at) as next_title
+FROM posts;
+\`\`\`
+
+## Full-Text Search
+\`\`\`sql
+-- Basic full-text search
+SELECT * FROM posts
+WHERE to_tsvector('english', title || ' ' || content) @@ plainto_tsquery('english', 'search terms');
+
+-- With ranking
+SELECT
+  title,
+  ts_rank(to_tsvector('english', content), query) as rank
+FROM posts, plainto_tsquery('english', 'search terms') query
+WHERE to_tsvector('english', content) @@ query
+ORDER BY rank DESC;
+
+-- Generated tsvector column (for performance)
+ALTER TABLE posts ADD COLUMN search_vector tsvector
+  GENERATED ALWAYS AS (to_tsvector('english', title || ' ' || COALESCE(content, ''))) STORED;
+CREATE INDEX idx_posts_search ON posts USING GIN (search_vector);
+\`\`\`
+
+## Query Optimization
+\`\`\`sql
+-- Analyze query plan
+EXPLAIN ANALYZE SELECT * FROM users WHERE email = 'test@example.com';
+
+-- Analyze with buffers and timing
+EXPLAIN (ANALYZE, BUFFERS, TIMING) SELECT * FROM posts WHERE author_id = '...';
+
+-- Update table statistics
+ANALYZE users;
+
+-- Check index usage
+SELECT
+  schemaname, tablename, indexname, idx_scan, idx_tup_read
+FROM pg_stat_user_indexes
+ORDER BY idx_scan DESC;
+
+-- Find slow queries (enable pg_stat_statements)
+SELECT query, calls, mean_exec_time, total_exec_time
+FROM pg_stat_statements
+ORDER BY total_exec_time DESC
+LIMIT 10;
+\`\`\`
+
+## Transactions & Locking
+\`\`\`sql
+-- Transaction with isolation level
+BEGIN TRANSACTION ISOLATION LEVEL SERIALIZABLE;
+-- ... operations ...
+COMMIT;
+
+-- Advisory locks (application-level)
+SELECT pg_advisory_lock(123);
+-- ... do work ...
+SELECT pg_advisory_unlock(123);
+
+-- Row-level lock
+SELECT * FROM accounts WHERE id = '...' FOR UPDATE;
+-- Now other transactions wait for this lock
+\`\`\`
+
+## ❌ DON'T
+- Use SELECT * in production queries
+- Create indexes on every column (maintain costs)
+- Use OFFSET for deep pagination
+- Store large blobs in PostgreSQL (use object storage)
+- Skip EXPLAIN ANALYZE for slow queries
+- Use implicit type conversions in WHERE clauses
+
+## ✅ DO
+- Use UUIDs or BIGSERIAL for primary keys
+- Create partial indexes for filtered queries
+- Use JSONB for flexible schema parts
+- Use CTEs for complex queries
+- Use cursor-based pagination for large datasets
+- Run ANALYZE after bulk data changes
+- Use connection pooling (PgBouncer)
+- Set appropriate work_mem for complex queries