ai-qakit 1.0.0

package/templates/.claude/skills/playwright/references/config.md

@@ -0,0 +1,391 @@
+# Playwright Configuration Reference
+
+## Base Configuration
+
+```typescript
+// playwright.config.ts
+import { defineConfig, devices } from '@playwright/test';
+import dotenv from 'dotenv';
+
+dotenv.config();
+
+export default defineConfig({
+  // Test directory
+  testDir: './tests/specs',
+  
+  // Run tests in parallel
+  fullyParallel: true,
+  
+  // Fail build on CI if test.only is left
+  forbidOnly: !!process.env.CI,
+  
+  // Retry failed tests
+  retries: process.env.CI ? 2 : 0,
+  
+  // Parallel workers
+  workers: process.env.CI ? 1 : undefined,
+  
+  // Reporter configuration
+  reporter: [
+    ['html', { outputFolder: 'reports/html', open: 'never' }],
+    ['junit', { outputFile: 'reports/junit.xml' }],
+    ['json', { outputFile: 'reports/results.json' }],
+    ['list'],
+  ],
+
+  // Shared settings for all projects
+  use: {
+    // Base URL
+    baseURL: process.env.WEB_BASE_URL || 'http://localhost:3000',
+    
+    // Collect trace on first retry
+    trace: 'on-first-retry',
+    
+    // Screenshot on failure
+    screenshot: 'only-on-failure',
+    
+    // Video on failure
+    video: 'retain-on-failure',
+    
+    // Timeouts
+    actionTimeout: 10000,
+    navigationTimeout: 30000,
+  },
+
+  // Browser projects
+  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'] },
+    },
+    {
+      name: 'mobile-safari',
+      use: { ...devices['iPhone 12'] },
+    },
+  ],
+
+  // Local dev server
+  webServer: process.env.CI ? undefined : {
+    command: 'npm run dev',
+    url: 'http://localhost:3000',
+    reuseExistingServer: !process.env.CI,
+  },
+});
+```
+
+## Environment-Specific Configs
+
+### Smoke Config
+
+```typescript
+// configs/playwright.smoke.config.ts
+import { defineConfig } from '@playwright/test';
+import baseConfig from '../playwright.config';
+
+export default defineConfig({
+  ...baseConfig,
+  testMatch: '**/*.spec.ts',
+  grep: /@smoke/,
+  retries: 0,
+  workers: 4,
+});
+```
+
+### Regression Config
+
+```typescript
+// configs/playwright.regression.config.ts
+import { defineConfig } from '@playwright/test';
+import baseConfig from '../playwright.config';
+
+export default defineConfig({
+  ...baseConfig,
+  testMatch: '**/*.spec.ts',
+  grep: /@regression/,
+  retries: 2,
+  workers: 2,
+});
+```
+
+### CI Config
+
+```typescript
+// configs/playwright.ci.config.ts
+import { defineConfig } from '@playwright/test';
+import baseConfig from '../playwright.config';
+
+export default defineConfig({
+  ...baseConfig,
+  forbidOnly: true,
+  retries: 2,
+  workers: 1,
+  reporter: [
+    ['junit', { outputFile: 'reports/junit.xml' }],
+    ['github'],
+  ],
+  use: {
+    ...baseConfig.use,
+    trace: 'on',
+    video: 'on',
+  },
+});
+```
+
+## Project Configuration
+
+### Desktop Browsers
+
+```typescript
+projects: [
+  {
+    name: 'chromium',
+    use: {
+      ...devices['Desktop Chrome'],
+      viewport: { width: 1920, height: 1080 },
+    },
+  },
+  {
+    name: 'firefox',
+    use: {
+      ...devices['Desktop Firefox'],
+      viewport: { width: 1920, height: 1080 },
+    },
+  },
+  {
+    name: 'webkit',
+    use: {
+      ...devices['Desktop Safari'],
+      viewport: { width: 1920, height: 1080 },
+    },
+  },
+]
+```
+
+### Mobile Devices
+
+```typescript
+projects: [
+  {
+    name: 'mobile-chrome',
+    use: {
+      ...devices['Pixel 5'],
+    },
+  },
+  {
+    name: 'mobile-safari',
+    use: {
+      ...devices['iPhone 12'],
+    },
+  },
+  {
+    name: 'tablet',
+    use: {
+      ...devices['iPad Pro 11'],
+    },
+  },
+]
+```
+
+### With Authentication
+
+```typescript
+projects: [
+  // Setup project - runs first
+  {
+    name: 'setup',
+    testMatch: /.*\.setup\.ts/,
+  },
+  // Tests that need auth
+  {
+    name: 'chromium',
+    use: {
+      ...devices['Desktop Chrome'],
+      storageState: '.auth/user.json',
+    },
+    dependencies: ['setup'],
+  },
+]
+```
+
+## Reporter Configuration
+
+### HTML Reporter
+
+```typescript
+reporter: [
+  ['html', {
+    outputFolder: 'reports/html',
+    open: 'never', // 'always' | 'never' | 'on-failure'
+  }],
+]
+```
+
+### JUnit Reporter (CI)
+
+```typescript
+reporter: [
+  ['junit', {
+    outputFile: 'reports/junit.xml',
+    embedAnnotationsAsProperties: true,
+  }],
+]
+```
+
+### Allure Reporter
+
+```typescript
+// Install: npm install allure-playwright
+reporter: [
+  ['allure-playwright', {
+    outputFolder: 'reports/allure-results',
+    detail: true,
+    suiteTitle: true,
+  }],
+]
+```
+
+### Custom Reporter
+
+```typescript
+reporter: [
+  ['./reporters/custom-reporter.ts'],
+]
+```
+
+## Timeout Configuration
+
+```typescript
+use: {
+  // Action timeout (click, fill, etc.)
+  actionTimeout: 10000,
+  
+  // Navigation timeout
+  navigationTimeout: 30000,
+},
+
+// Test timeout
+timeout: 60000,
+
+// Expect timeout
+expect: {
+  timeout: 5000,
+},
+```
+
+## Trace Configuration
+
+```typescript
+use: {
+  // 'on' | 'off' | 'on-first-retry' | 'retain-on-failure'
+  trace: 'on-first-retry',
+  
+  // Trace options
+  trace: {
+    mode: 'on-first-retry',
+    screenshots: true,
+    snapshots: true,
+    sources: true,
+  },
+}
+```
+
+## Screenshot Configuration
+
+```typescript
+use: {
+  // 'on' | 'off' | 'only-on-failure'
+  screenshot: 'only-on-failure',
+  
+  // Screenshot options
+  screenshot: {
+    mode: 'only-on-failure',
+    fullPage: true,
+  },
+}
+```
+
+## Video Configuration
+
+```typescript
+use: {
+  // 'on' | 'off' | 'retain-on-failure' | 'on-first-retry'
+  video: 'retain-on-failure',
+  
+  // Video options
+  video: {
+    mode: 'retain-on-failure',
+    size: { width: 1280, height: 720 },
+  },
+}
+```
+
+## Global Setup/Teardown
+
+```typescript
+// playwright.config.ts
+export default defineConfig({
+  globalSetup: require.resolve('./global-setup.ts'),
+  globalTeardown: require.resolve('./global-teardown.ts'),
+});
+
+// global-setup.ts
+import { chromium, FullConfig } from '@playwright/test';
+
+async function globalSetup(config: FullConfig) {
+  const browser = await chromium.launch();
+  const page = await browser.newPage();
+  
+  // Setup tasks (e.g., login, seed data)
+  await page.goto('/login');
+  // ...
+  
+  await browser.close();
+}
+
+export default globalSetup;
+```
+
+## Environment Variables
+
+```ini
+# .env.example
+WEB_BASE_URL=https://staging.example.com
+API_BASE_URL=https://api.staging.example.com
+TEST_USER_EMAIL=test@example.com
+TEST_USER_PASSWORD=password123
+CI=false
+```
+
+## npm Scripts
+
+```json
+{
+  "scripts": {
+    "test": "playwright test",
+    "test:smoke": "playwright test --grep @smoke",
+    "test:regression": "playwright test --grep @regression",
+    "test:chromium": "playwright test --project=chromium",
+    "test:firefox": "playwright test --project=firefox",
+    "test:webkit": "playwright test --project=webkit",
+    "test:mobile": "playwright test --project=mobile-chrome --project=mobile-safari",
+    "test:headed": "playwright test --headed",
+    "test:debug": "PWDEBUG=1 playwright test --headed",
+    "test:ui": "playwright test --ui",
+    "test:ci": "playwright test --config=configs/playwright.ci.config.ts",
+    "report": "playwright show-report reports/html",
+    "trace": "playwright show-trace"
+  }
+}
+```

package/templates/.claude/skills/problem-solving/SKILL.md

@@ -0,0 +1,96 @@
+---
+name: Problem-Solving Techniques
+description: Apply systematic problem-solving techniques for complexity spirals (simplification cascades), innovation blocks (collision-zone thinking), recurring patterns (meta-pattern recognition), assumption constraints (inversion exercise), scale uncertainty (scale game), and dispatch when stuck. Techniques derived from Microsoft Amplifier project patterns adapted for immediate application.
+version: 2.0.0
+---
+
+# Problem-Solving Techniques
+
+Systematic approaches for different types of stuck-ness. Each technique targets specific problem patterns.
+
+## When to Use
+
+Apply when encountering:
+- **Complexity spiraling** - Multiple implementations, growing special cases, excessive branching
+- **Innovation blocks** - Conventional solutions inadequate, need breakthrough thinking
+- **Recurring patterns** - Same issue across domains, reinventing solutions
+- **Assumption constraints** - Forced into "only way", can't question premise
+- **Scale uncertainty** - Production readiness unclear, edge cases unknown
+- **General stuck-ness** - Unsure which technique applies
+
+## Quick Dispatch
+
+**Match symptom to technique:**
+
+| Stuck Symptom | Technique | Reference |
+|---------------|-----------|-----------|
+| Same thing implemented 5+ ways, growing special cases | **Simplification Cascades** | `references/simplification-cascades.md` |
+| Conventional solutions inadequate, need breakthrough | **Collision-Zone Thinking** | `references/collision-zone-thinking.md` |
+| Same issue in different places, reinventing wheels | **Meta-Pattern Recognition** | `references/meta-pattern-recognition.md` |
+| Solution feels forced, "must be done this way" | **Inversion Exercise** | `references/inversion-exercise.md` |
+| Will this work at production? Edge cases unclear? | **Scale Game** | `references/scale-game.md` |
+| Unsure which technique to use | **When Stuck** | `references/when-stuck.md` |
+
+## Core Techniques
+
+### 1. Simplification Cascades
+Find one insight eliminating multiple components. "If this is true, we don't need X, Y, Z."
+
+**Key insight:** Everything is a special case of one general pattern.
+
+**Red flag:** "Just need to add one more case..." (repeating forever)
+
+### 2. Collision-Zone Thinking
+Force unrelated concepts together to discover emergent properties. "What if we treated X like Y?"
+
+**Key insight:** Revolutionary ideas from deliberate metaphor-mixing.
+
+**Red flag:** "I've tried everything in this domain"
+
+### 3. Meta-Pattern Recognition
+Spot patterns appearing in 3+ domains to find universal principles.
+
+**Key insight:** Patterns in how patterns emerge reveal reusable abstractions.
+
+**Red flag:** "This problem is unique" (probably not)
+
+### 4. Inversion Exercise
+Flip core assumptions to reveal hidden constraints. "What if the opposite were true?"
+
+**Key insight:** Valid inversions reveal context-dependence of "rules."
+
+**Red flag:** "There's only one way to do this"
+
+### 5. Scale Game
+Test at extremes (1000x bigger/smaller, instant/year-long) to expose fundamental truths.
+
+**Key insight:** What works at one scale fails at another.
+
+**Red flag:** "Should scale fine" (without testing)
+
+## Application Process
+
+1. **Identify stuck-type** - Match symptom to technique above
+2. **Load detailed reference** - Read specific technique from `references/`
+3. **Apply systematically** - Follow technique's process
+4. **Document insights** - Record what worked/failed
+5. **Combine if needed** - Some problems need multiple techniques
+
+## Combining Techniques
+
+Powerful combinations:
+- **Simplification + Meta-pattern** - Find pattern, then simplify all instances
+- **Collision + Inversion** - Force metaphor, then invert its assumptions
+- **Scale + Simplification** - Extremes reveal what to eliminate
+- **Meta-pattern + Scale** - Universal patterns tested at extremes
+
+## References
+
+Load detailed guides as needed:
+- `references/when-stuck.md` - Dispatch flowchart and decision tree
+- `references/simplification-cascades.md` - Cascade detection and extraction
+- `references/collision-zone-thinking.md` - Metaphor collision process
+- `references/meta-pattern-recognition.md` - Pattern abstraction techniques
+- `references/inversion-exercise.md` - Assumption flipping methodology
+- `references/scale-game.md` - Extreme testing procedures
+- `references/attribution.md` - Source and adaptation notes

package/templates/.claude/skills/problem-solving/references/attribution.md

@@ -0,0 +1,69 @@
+# Problem-Solving Skills - Attribution
+
+These skills were derived from agent patterns in the Microsoft Amplifier project.
+
+## Source Repository
+
+- **Name:** Amplifier
+- **URL:** https://github.com/microsoft/amplifier
+- **Commit:** 2adb63f858e7d760e188197c8e8d4c1ef721e2a6
+- **Date:** 2025-10-10
+
+## Skills Derived from Amplifier Agents
+
+### From insight-synthesizer agent:
+- **simplification-cascades** - Finding insights that eliminate multiple components
+- **collision-zone-thinking** - Forcing unrelated concepts together for breakthroughs
+- **meta-pattern-recognition** - Spotting patterns across 3+ domains
+- **inversion-exercise** - Flipping assumptions to reveal alternatives
+- **scale-game** - Testing at extremes to expose fundamental truths
+
+### From ambiguity-guardian agent:
+- **preserving-productive-tensions** - Preserving multiple valid approaches (in architecture skill)
+
+### From knowledge-archaeologist agent:
+- **tracing-knowledge-lineages** - Understanding how ideas evolved (in research skill)
+
+### Dispatch pattern:
+- **when-stuck** - Maps stuck-symptoms to appropriate technique
+
+## What Was Adapted
+
+The Amplifier agents are specialized long-lived agents with structured JSON output. These skills extract the core problem-solving techniques and adapt them as:
+
+- **Scannable quick-reference guides** (~60-80 lines each)
+- **Symptom-based discovery** via when_to_use descriptions
+- **Immediate application** without special tooling
+- **Composable patterns** through dispatch system
+- **Progressive disclosure** via SKILL.md + references structure
+
+## Core Insight
+
+Agent capabilities are domain-agnostic patterns. Whether packaged as "amplifier agent" or "problem-solving skill", the underlying technique is the same.
+
+We extracted the techniques and made them:
+- Portable across contexts
+- Immediately applicable
+- Token-efficient through progressive disclosure
+- Discoverable through symptom-matching
+- Combinable for complex problems
+
+## License
+
+Original Amplifier project uses MIT License. These adapted skills maintain attribution and follow the same open spirit.
+
+## Adaptation Notes
+
+**Changes from original:**
+- Converted from long-lived agent to scannable reference
+- Added symptom-based dispatch system
+- Removed JSON output requirements
+- Focused on immediate application
+- Added concrete examples
+- Structured for progressive disclosure
+
+**Preserved from original:**
+- Core problem-solving techniques
+- Recognition patterns
+- Application processes
+- Fundamental insights

package/templates/.claude/skills/problem-solving/references/collision-zone-thinking.md

@@ -0,0 +1,79 @@
+# Collision-Zone Thinking
+
+Force unrelated concepts together to discover emergent properties. "What if we treated X like Y?"
+
+## Core Principle
+
+Revolutionary insights from deliberate metaphor-mixing. Treat X like Y and see what emerges.
+
+## When to Use
+
+| Symptom | Action |
+|---------|--------|
+| Stuck in conventional thinking | Force wild domain collision |
+| Solutions feel incremental | Need breakthrough, not optimization |
+| "Tried everything in this domain" | Import concepts from elsewhere |
+| Need innovation, not iteration | Deliberately mix unrelated ideas |
+
+## Quick Reference Collisions
+
+| Treat This | Like This | Discovers |
+|------------|-----------|-----------|
+| Code organization | DNA/genetics | Mutation testing, evolutionary algorithms |
+| Service architecture | Lego bricks | Composable microservices, plug-and-play |
+| Data management | Water flow | Streaming, data lakes, flow-based systems |
+| Request handling | Postal mail | Message queues, async processing |
+| Error handling | Circuit breakers | Fault isolation, graceful degradation |
+
+## Process
+
+1. **Pick two unrelated concepts** from different domains
+2. **Force combination** - "What if we treated [A] like [B]?"
+3. **Explore emergent properties** - What new capabilities appear?
+4. **Test boundaries** - Where does the metaphor break?
+5. **Extract insight** - What did we learn?
+
+## Detailed Example
+
+**Problem:** Complex distributed system with cascading failures
+
+**Collision:** "What if we treated services like electrical circuits?"
+
+**Emergent properties:**
+- Circuit breakers (disconnect on overload)
+- Fuses (one-time failure protection)
+- Ground faults (error isolation)
+- Load balancing (current distribution)
+- Voltage regulation (rate limiting)
+
+**Where it works:** Preventing cascade failures, fault isolation
+
+**Where it breaks:** Circuits don't have retry logic, healing mechanisms
+
+**Insight gained:** Failure isolation patterns from electrical engineering
+
+## Best Source Domains
+
+Rich domains for concept mining:
+- **Physics** - Forces, thermodynamics, relativity
+- **Biology** - Evolution, ecosystems, immune systems
+- **Economics** - Markets, incentives, game theory
+- **Psychology** - Cognition, behavior, motivation
+- **Architecture** - Structure, flow, space utilization
+
+## Red Flags
+
+You need collision-zone thinking when:
+- "I've tried everything in this domain"
+- Solutions feel incremental, not breakthrough
+- Stuck in conventional thinking
+- Need innovation, not optimization
+- "Standard approach isn't working"
+
+## Remember
+
+- Wild combinations often yield best insights
+- Test metaphor boundaries rigorously
+- Document even failed collisions (they teach)
+- Breakthrough > incremental improvement
+- Question: "What would [domain expert] do?"