qualia-framework 2.1.0

package/framework/skills/supabase/references/templates.md

@@ -0,0 +1,159 @@
+# Supabase Code Templates
+
+> Claude: Read this file on-demand when you need specific code patterns.
+
+## Table + RLS Pattern
+
+```sql
+CREATE TABLE items (
+  id UUID DEFAULT gen_random_uuid() PRIMARY KEY,
+  user_id UUID REFERENCES auth.users(id) ON DELETE CASCADE NOT NULL,
+  title TEXT NOT NULL,
+  created_at TIMESTAMPTZ DEFAULT NOW()
+);
+
+ALTER TABLE items ENABLE ROW LEVEL SECURITY;
+
+CREATE POLICY "Users manage own items" ON items
+  FOR ALL USING (auth.uid() = user_id)
+  WITH CHECK (auth.uid() = user_id);
+```
+
+## Auth Setup (Next.js)
+
+```typescript
+import { createClient } from '@supabase/supabase-js'
+
+const supabase = createClient(
+  process.env.NEXT_PUBLIC_SUPABASE_URL!,
+  process.env.NEXT_PUBLIC_SUPABASE_ANON_KEY!,
+  { auth: { flowType: 'pkce', autoRefreshToken: true, persistSession: true, detectSessionInUrl: true } }
+)
+
+// OAuth
+await supabase.auth.signInWithOAuth({
+  provider: 'google',
+  options: { redirectTo: `${window.location.origin}/auth/callback` }
+})
+
+// Token refresh
+supabase.auth.onAuthStateChange((event, session) => {
+  if (event === 'TOKEN_REFRESHED') console.log('Token refreshed')
+})
+```
+
+## Auto-create Profile on Signup
+
+```sql
+CREATE OR REPLACE FUNCTION handle_new_user()
+RETURNS TRIGGER AS $$
+BEGIN
+  INSERT INTO public.profiles (id, email, full_name)
+  VALUES (NEW.id, NEW.email, NEW.raw_user_meta_data->>'full_name');
+  RETURN NEW;
+END;
+$$ LANGUAGE plpgsql SECURITY DEFINER;
+
+CREATE TRIGGER on_auth_user_created
+  AFTER INSERT ON auth.users
+  FOR EACH ROW EXECUTE FUNCTION handle_new_user();
+```
+
+## Realtime Subscriptions
+
+```typescript
+// Postgres changes
+supabase.channel('changes')
+  .on('postgres_changes', { event: '*', schema: 'public', table: 'messages' },
+    payload => console.log('Change:', payload))
+  .subscribe()
+
+// Presence
+const channel = supabase.channel(`room:${roomId}`)
+  .on('presence', { event: 'sync' }, () => console.log('Online:', channel.presenceState()))
+  .subscribe(async (status) => {
+    if (status === 'SUBSCRIBED') await channel.track({ user_id: user.id })
+  })
+```
+
+## Storage Upload
+
+```typescript
+const { data, error } = await supabase.storage
+  .from('avatars')
+  .upload(path, file, { cacheControl: '3600' })
+
+const { data: { publicUrl } } = supabase.storage.from('avatars').getPublicUrl(path)
+```
+
+## Edge Function Template
+
+```typescript
+import "jsr:@supabase/functions-js/edge-runtime.d.ts"
+import { createClient } from "https://esm.sh/@supabase/supabase-js@2"
+
+Deno.serve(async (req: Request) => {
+  if (req.method === "OPTIONS") {
+    return new Response(null, {
+      headers: {
+        "Access-Control-Allow-Origin": Deno.env.get("ALLOWED_ORIGIN") || "*",
+        "Access-Control-Allow-Methods": "POST, OPTIONS",
+        "Access-Control-Allow-Headers": "Content-Type, Authorization",
+      },
+    })
+  }
+
+  try {
+    const body = await req.json()
+    // Use user-context client (respects RLS):
+    const supabase = createClient(
+      Deno.env.get("SUPABASE_URL")!,
+      Deno.env.get("SUPABASE_ANON_KEY")!,
+      { global: { headers: { Authorization: req.headers.get("Authorization")! } } }
+    )
+
+    return new Response(JSON.stringify({ success: true }), {
+      headers: { "Content-Type": "application/json" },
+    })
+  } catch (error) {
+    console.error("Function error:", error)
+    return new Response(JSON.stringify({ error: "Internal server error" }), {
+      status: 500,
+      headers: { "Content-Type": "application/json" },
+    })
+  }
+})
+```
+
+## Deno Imports (NOT npm)
+
+```typescript
+import { createClient } from "https://esm.sh/@supabase/supabase-js@2"
+import Anthropic from "https://esm.sh/@anthropic-ai/sdk"
+import { z } from "https://deno.land/x/zod/mod.ts"
+```
+
+## Common Error Fixes
+
+| Error | Fix |
+|-------|-----|
+| `PGRST116: 0 rows` | Use `.maybeSingle()` not `.single()` |
+| `duplicate key` | Use `.upsert({ ... }, { onConflict: 'id' })` |
+| `violates RLS policy` | Check `auth.uid()` in policy, verify INSERT has `WITH CHECK` |
+| `Invalid login credentials` | Check email confirmed, JWT not expired, PKCE flow |
+
+## Query Optimization
+
+```sql
+-- Analyze slow queries
+EXPLAIN ANALYZE SELECT ...;
+
+-- Composite index
+CREATE INDEX idx_posts_created_likes ON posts(created_at DESC, likes_count DESC)
+WHERE deleted_at IS NULL;
+
+-- Materialized view for aggregations
+CREATE MATERIALIZED VIEW post_stats AS
+SELECT user_id, COUNT(*) as total_posts FROM posts GROUP BY user_id;
+REFRESH MATERIALIZED VIEW CONCURRENTLY post_stats;
+```

package/framework/skills/team/SKILL.md

@@ -0,0 +1,67 @@
+---
+name: team
+description: "Coordinate specialist agent teams for complex tasks — full-stack development, code review, or deployment. Use this skill whenever the user says 'team', 'spawn agents', 'full-stack build', 'team review', 'team ship', or wants to orchestrate multiple specialist agents working in parallel. Also trigger when user needs fan-out parallel work (frontend + backend + test), multi-perspective code review, or pipeline deployment coordination."
+---
+
+# Team — Agent Team Orchestration
+
+Coordinate specialist agent teams to handle complex tasks through parallel or pipeline patterns.
+
+## Usage
+
+`/team full-stack "Build user dashboard with CRUD"`
+`/team review "Audit the auth module"`
+`/team ship`
+
+## Available Templates
+
+| Template | Pattern | Agents | Use Case |
+|----------|---------|--------|----------|
+| `full-stack` | fan-out → test | frontend + backend + test | Building features |
+| `review` | fan-out → synthesize | simplicity + performance + TS quality | Code review |
+| `ship` | pipeline | quality gate → deploy → verify | Deployment |
+
+## Process
+
+### 1. Parse Arguments
+
+Extract from arguments:
+
+- **template** — First word: `full-stack`, `review`, or `ship`
+- **task** — Remaining text (optional for `ship`)
+
+If no arguments: show usage and available templates.
+
+### 2. Load Team Template
+
+```bash
+TEMPLATE_PATH="$HOME/.claude/agents/teams/${TEMPLATE}-team.md"
+```
+
+Read the template file. If not found, error with available templates.
+
+### 3. Load Project Context
+
+```bash
+STATE=$(cat .planning/STATE.md 2>/dev/null || echo "No STATE.md found")
+PROJECT_DIR=$(pwd)
+```
+
+### 4. Spawn Team Orchestrator
+
+Launch a general-purpose subagent with:
+
+- The team orchestrator instructions from `/home/qualia/.claude/agents/team-orchestrator.md`
+- The team template content
+- The task description (or "Ship current project to production" for ship template)
+- Current project state and directory
+
+The orchestrator spawns specialist agents, coordinates their work, resolves conflicts, and produces summary output.
+
+### 5. Report Results
+
+Read the produced summary and present to user:
+
+- `full-stack` → TEAM-SUMMARY.md
+- `review` → REVIEW-REPORT.md
+- `ship` → SHIP-REPORT.md

package/framework/skills/test-runner/SKILL.md

@@ -0,0 +1,202 @@
+---
+name: test-runner
+description: Automate testing for Qualia Solutions projects - runs unit tests, integration tests, generates coverage reports, and creates missing tests
+---
+
+# Automated Testing Skill
+
+Handles all testing operations for your projects.
+
+## Run Tests (canonical reference)
+
+This is the single source of truth for test detection and execution in the Qualia workflow.
+Referenced by: `/qualia-verify-work`, `/ship`.
+
+### Detection
+```bash
+# Unit/Integration
+[ -f package.json ] && grep -q '"test"' package.json && echo "HAS_UNIT=true"
+
+# E2E - Playwright
+ls playwright.config.* 2>/dev/null && echo "HAS_PLAYWRIGHT=true"
+
+# E2E - Cypress
+ls cypress.config.* 2>/dev/null && echo "HAS_CYPRESS=true"
+
+# Python
+[ -f pytest.ini ] || [ -f setup.cfg ] || [ -f pyproject.toml ] && echo "HAS_PYTEST=true"
+```
+
+### Execution Order
+1. Unit/Integration: `npm test` (or `pytest --cov`)
+2. E2E Playwright: `npx playwright test`
+3. E2E Cypress: `npx cypress run`
+4. Report: X passed, Y failed, Z skipped per runner
+
+### Result Format
+```
+Test Results: {runner}
+- Passed: X
+- Failed: Y
+- Skipped: Z
+{If failures: list names}
+```
+
+## Auto-detect and Run Tests
+
+When you say "run tests", I automatically:
+
+### For JavaScript/TypeScript Projects
+```bash
+# Detect test runner
+if [ -f "package.json" ]; then
+  if grep -q "jest" package.json; then
+    npm test -- --coverage
+  elif grep -q "vitest" package.json; then
+    npm run test -- --coverage
+  elif grep -q "mocha" package.json; then
+    npm test
+  fi
+fi
+```
+
+### For Python Projects
+```bash
+# Run pytest with coverage
+if [ -f "requirements.txt" ]; then
+  pytest --cov=src --cov-report=html --cov-report=term
+fi
+```
+
+## Generate Missing Tests
+
+When you say "create tests for X", I generate:
+
+### React Component Test
+```typescript
+// Button.test.tsx
+import { render, screen, fireEvent } from '@testing-library/react'
+import { Button } from './Button'
+
+describe('Button', () => {
+  it('renders with text', () => {
+    render(<Button>Click me</Button>)
+    expect(screen.getByText('Click me')).toBeInTheDocument()
+  })
+
+  it('handles click events', () => {
+    const handleClick = jest.fn()
+    render(<Button onClick={handleClick}>Click</Button>)
+    fireEvent.click(screen.getByText('Click'))
+    expect(handleClick).toHaveBeenCalledTimes(1)
+  })
+})
+```
+
+### Python Function Test
+```python
+# test_agent.py
+import pytest
+from agent import QualiaAgent
+
+class TestQualiaAgent:
+    @pytest.fixture
+    def agent(self):
+        return QualiaAgent("test")
+
+    async def test_process_input(self, agent):
+        response = await agent.process("Hello")
+        assert response is not None
+        assert isinstance(response, str)
+
+    async def test_error_handling(self, agent):
+        with pytest.raises(ValueError):
+            await agent.process("")
+```
+
+## Coverage Reports
+
+### Generate Coverage
+```bash
+# JavaScript
+npm test -- --coverage --coverageReporters=html
+
+# Python
+pytest --cov --cov-report=html
+
+# Open report
+open coverage/index.html  # or htmlcov/index.html
+```
+
+### Coverage Requirements
+- Minimum 80% overall
+- 90% for critical paths
+- 100% for utility functions
+
+## Test Types
+
+### Unit Tests
+- Test individual functions
+- Mock external dependencies
+- Fast execution (<1s per test)
+
+### Integration Tests
+```javascript
+// API integration test
+describe('API Integration', () => {
+  it('creates user successfully', async () => {
+    const response = await request(app)
+      .post('/api/users')
+      .send({ email: 'test@example.com' })
+
+    expect(response.status).toBe(201)
+    expect(response.body).toHaveProperty('id')
+  })
+})
+```
+
+### E2E Tests
+```javascript
+// Playwright E2E test
+test('user can complete signup flow', async ({ page }) => {
+  await page.goto('/')
+  await page.click('text=Sign Up')
+  await page.fill('[name=email]', 'test@example.com')
+  await page.fill('[name=password]', 'password123')
+  await page.click('button[type=submit]')
+  await expect(page).toHaveURL('/dashboard')
+})
+```
+
+## CI/CD Integration
+
+### GitHub Actions
+```yaml
+name: Tests
+on: [push, pull_request]
+jobs:
+  test:
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v2
+      - run: npm ci
+      - run: npm test -- --coverage
+      - uses: codecov/codecov-action@v2
+```
+
+## Quick Commands
+
+- "test" → Run all tests
+- "test unit" → Run unit tests only
+- "test integration" → Run integration tests
+- "test e2e" → Run end-to-end tests
+- "create tests" → Generate missing tests
+- "coverage" → Generate coverage report
+
+## Test Watching
+
+```bash
+# Watch mode for development
+npm test -- --watch
+# or
+pytest-watch