@rotifer/playground 0.5.0-alpha.2 → 0.7.0

package/genes/testing-strategist/SKILL.md

@@ -0,0 +1,500 @@
+---
+name: testing-strategist
+description: Design testing strategies for AI and Web3 applications. Create test cases, mock data, and CI configurations. Use when writing tests, setting up test infrastructure, or when the user mentions testing, test coverage, unit test, integration test, or e2e.
+---
+
+# Testing Strategist (测试策略师)
+
+**Goal**: 为 AI + Web3 应用设计高效的测试策略，确保代码质量和系统稳定性。
+
+**OPC 原则**: 测试要精准，不追求 100% 覆盖率，聚焦核心路径。
+
+---
+
+## Testing Philosophy
+
+```
+测试金字塔 (OPC 版):
+                    ┌─────────┐
+                    │  E2E    │  ← 最少 (关键用户流程)
+                   ─┴─────────┴─
+                 ┌───────────────┐
+                 │  Integration  │  ← 适量 (API/DB)
+               ──┴───────────────┴──
+             ┌───────────────────────┐
+             │      Unit Tests       │  ← 最多 (纯函数)
+           ──┴───────────────────────┴──
+```
+
+---
+
+## 1. Unit Testing
+
+### Pure Functions (优先测试)
+
+```typescript
+// utils/format.test.ts
+import { describe, it, expect } from 'vitest'
+import { truncateAddress, formatTokenAmount } from './format'
+
+describe('truncateAddress', () => {
+  it('truncates correctly', () => {
+    expect(truncateAddress('0x1234567890abcdef1234567890abcdef12345678'))
+      .toBe('0x1234...5678')
+  })
+  
+  it('handles short addresses', () => {
+    expect(truncateAddress('0x1234')).toBe('0x1234')
+  })
+  
+  it('handles empty input', () => {
+    expect(truncateAddress('')).toBe('')
+  })
+})
+
+describe('formatTokenAmount', () => {
+  it('formats large numbers with decimals', () => {
+    expect(formatTokenAmount(1500000000000000000n, 18)).toBe('1.5')
+  })
+  
+  it('handles zero', () => {
+    expect(formatTokenAmount(0n, 18)).toBe('0')
+  })
+})
+```
+
+### Testing Hooks
+
+```typescript
+// hooks/useWallet.test.ts
+import { renderHook, act } from '@testing-library/react'
+import { useWallet } from './useWallet'
+
+describe('useWallet', () => {
+  it('starts disconnected', () => {
+    const { result } = renderHook(() => useWallet())
+    expect(result.current.status).toBe('disconnected')
+  })
+  
+  it('connects successfully', async () => {
+    const { result } = renderHook(() => useWallet())
+    
+    await act(async () => {
+      await result.current.connect()
+    })
+    
+    expect(result.current.status).toBe('connected')
+  })
+})
+```
+
+---
+
+## 2. AI Testing Strategies
+
+### Response Structure Testing
+
+```typescript
+// ai/analyzer.test.ts
+import { describe, it, expect } from 'vitest'
+import { analyzeText } from './analyzer'
+import { AnalysisSchema } from './schemas'
+
+describe('analyzeText', () => {
+  it('returns valid schema', async () => {
+    const result = await analyzeText('Test input')
+    
+    // 验证结构
+    expect(() => AnalysisSchema.parse(result)).not.toThrow()
+  })
+  
+  it('handles empty input gracefully', async () => {
+    const result = await analyzeText('')
+    
+    expect(result.error).toBe('EMPTY_INPUT')
+  })
+})
+```
+
+### AI Response Mocking
+
+```typescript
+// __mocks__/ai.ts
+export const mockAIResponse = (response: unknown) => {
+  vi.mock('ai', () => ({
+    generateObject: vi.fn().mockResolvedValue({ object: response }),
+    generateText: vi.fn().mockResolvedValue({ text: JSON.stringify(response) }),
+  }))
+}
+
+// 使用
+describe('ChatService', () => {
+  beforeEach(() => {
+    mockAIResponse({
+      summary: 'Test summary',
+      sentiment: 'positive',
+    })
+  })
+  
+  it('processes AI response correctly', async () => {
+    const result = await chatService.analyze('input')
+    expect(result.summary).toBe('Test summary')
+  })
+})
+```
+
+### Snapshot Testing for Prompts
+
+```typescript
+// prompts/analyzer.test.ts
+import { buildAnalyzerPrompt } from './analyzer'
+
+describe('Analyzer Prompt', () => {
+  it('generates consistent prompt', () => {
+    const prompt = buildAnalyzerPrompt({
+      input: 'Test data',
+      context: 'Financial',
+    })
+    
+    expect(prompt).toMatchSnapshot()
+  })
+})
+```
+
+### Deterministic Testing
+
+```typescript
+// 使用固定 seed 测试 AI 行为一致性
+describe('AI Consistency', () => {
+  it('produces consistent output for same input', async () => {
+    const input = 'Analyze this market data'
+    
+    const results = await Promise.all([
+      analyzeWithSeed(input, 42),
+      analyzeWithSeed(input, 42),
+    ])
+    
+    expect(results[0]).toEqual(results[1])
+  })
+})
+```
+
+---
+
+## 3. Web3 Testing Strategies
+
+### Contract Interaction Mocking
+
+```typescript
+// __mocks__/wagmi.ts
+import { vi } from 'vitest'
+
+export const mockUseAccount = (overrides = {}) => {
+  return {
+    address: '0x1234567890abcdef1234567890abcdef12345678',
+    isConnected: true,
+    chainId: 1,
+    ...overrides,
+  }
+}
+
+export const mockUseWriteContract = () => ({
+  writeContract: vi.fn(),
+  isPending: false,
+  error: null,
+})
+```
+
+### Transaction Flow Testing
+
+```typescript
+// hooks/useTransfer.test.ts
+describe('useTransfer', () => {
+  it('handles successful transfer', async () => {
+    const { result } = renderHook(() => useTransfer())
+    
+    await act(async () => {
+      await result.current.transfer('0x...', 1000000000000000000n)
+    })
+    
+    expect(result.current.status).toBe('confirmed')
+    expect(result.current.hash).toBeDefined()
+  })
+  
+  it('handles insufficient balance', async () => {
+    mockBalance(0n) // 余额为 0
+    
+    const { result } = renderHook(() => useTransfer())
+    
+    await act(async () => {
+      await result.current.transfer('0x...', 1000000000000000000n)
+    })
+    
+    expect(result.current.error?.code).toBe('INSUFFICIENT_BALANCE')
+  })
+  
+  it('handles network switch during tx', async () => {
+    const { result } = renderHook(() => useTransfer())
+    
+    // 发起交易
+    act(() => { result.current.transfer('0x...', 1n) })
+    
+    // 模拟网络切换
+    act(() => { mockChainSwitch(137) })
+    
+    expect(result.current.error?.code).toBe('NETWORK_CHANGED')
+  })
+})
+```
+
+### BigInt Edge Cases
+
+```typescript
+describe('BigInt Handling', () => {
+  it('handles max uint256', () => {
+    const maxUint256 = 2n ** 256n - 1n
+    expect(formatTokenAmount(maxUint256, 18)).not.toThrow()
+  })
+  
+  it('handles precision correctly', () => {
+    // 0.000000000000000001 ETH (1 wei)
+    expect(formatTokenAmount(1n, 18)).toBe('0.000000000000000001')
+  })
+})
+```
+
+---
+
+## 4. Integration Testing
+
+### API Integration
+
+```typescript
+// api/chat.integration.test.ts
+import { describe, it, expect } from 'vitest'
+
+describe('Chat API', () => {
+  it('POST /api/chat returns streamed response', async () => {
+    const response = await fetch('/api/chat', {
+      method: 'POST',
+      body: JSON.stringify({ message: 'Hello' }),
+    })
+    
+    expect(response.status).toBe(200)
+    expect(response.headers.get('content-type')).toContain('text/event-stream')
+  })
+  
+  it('handles rate limiting', async () => {
+    // 快速发送多个请求
+    const responses = await Promise.all(
+      Array(10).fill(null).map(() => 
+        fetch('/api/chat', { method: 'POST', body: '{}' })
+      )
+    )
+    
+    const rateLimited = responses.filter(r => r.status === 429)
+    expect(rateLimited.length).toBeGreaterThan(0)
+  })
+})
+```
+
+### Database Integration
+
+```typescript
+// db/users.integration.test.ts
+describe('User Repository', () => {
+  beforeEach(async () => {
+    await db.user.deleteMany()
+  })
+  
+  it('creates and retrieves user', async () => {
+    const user = await userRepo.create({
+      address: '0x1234...',
+      email: 'test@example.com',
+    })
+    
+    const found = await userRepo.findByAddress('0x1234...')
+    expect(found).toEqual(user)
+  })
+})
+```
+
+---
+
+## 5. E2E Testing
+
+### Critical User Flows
+
+```typescript
+// e2e/chat-flow.spec.ts
+import { test, expect } from '@playwright/test'
+
+test('complete chat flow', async ({ page }) => {
+  await page.goto('/')
+  
+  // 连接钱包
+  await page.click('[data-testid="connect-wallet"]')
+  await page.click('[data-testid="metamask"]')
+  
+  // 发送消息
+  await page.fill('[data-testid="chat-input"]', 'Hello AI')
+  await page.click('[data-testid="send-button"]')
+  
+  // 等待响应
+  await expect(page.locator('[data-testid="ai-response"]')).toBeVisible({
+    timeout: 30000,
+  })
+  
+  // 验证响应内容
+  const response = await page.textContent('[data-testid="ai-response"]')
+  expect(response?.length).toBeGreaterThan(0)
+})
+```
+
+### Web3 Flow
+
+```typescript
+// e2e/transaction-flow.spec.ts
+test('complete transaction flow', async ({ page }) => {
+  await page.goto('/swap')
+  
+  // 输入金额
+  await page.fill('[data-testid="amount-input"]', '0.1')
+  
+  // 检查 gas 估算
+  await expect(page.locator('[data-testid="gas-estimate"]')).toBeVisible()
+  
+  // 点击交易
+  await page.click('[data-testid="swap-button"]')
+  
+  // 等待钱包确认
+  await expect(page.locator('[data-testid="tx-pending"]')).toBeVisible()
+  
+  // 等待确认 (mock 环境)
+  await expect(page.locator('[data-testid="tx-confirmed"]')).toBeVisible({
+    timeout: 60000,
+  })
+})
+```
+
+---
+
+## 6. Test Data & Mocks
+
+### Mock Data Factory
+
+```typescript
+// __fixtures__/factory.ts
+import { faker } from '@faker-js/faker'
+
+export const createUser = (overrides = {}) => ({
+  id: faker.string.uuid(),
+  address: `0x${faker.string.hexadecimal({ length: 40 })}`,
+  email: faker.internet.email(),
+  createdAt: faker.date.past(),
+  ...overrides,
+})
+
+export const createTransaction = (overrides = {}) => ({
+  hash: `0x${faker.string.hexadecimal({ length: 64 })}`,
+  from: `0x${faker.string.hexadecimal({ length: 40 })}`,
+  to: `0x${faker.string.hexadecimal({ length: 40 })}`,
+  value: BigInt(faker.number.int({ min: 1, max: 1000000 })) * 10n ** 18n,
+  status: 'confirmed',
+  ...overrides,
+})
+```
+
+### AI Response Fixtures
+
+```typescript
+// __fixtures__/ai-responses.ts
+export const AI_RESPONSES = {
+  ANALYSIS_SUCCESS: {
+    summary: 'Market shows bullish trends',
+    sentiment: 'positive',
+    confidence: 0.87,
+  },
+  ANALYSIS_UNCERTAIN: {
+    summary: 'Insufficient data',
+    sentiment: 'neutral',
+    confidence: 0.45,
+  },
+  ERROR_RATE_LIMITED: {
+    ok: false,
+    error: { code: 'RATE_LIMITED', retryAfter: 60 },
+  },
+}
+```
+
+---
+
+## 7. CI Configuration
+
+### GitHub Actions
+
+```yaml
+# .github/workflows/test.yml
+name: Test
+
+on: [push, pull_request]
+
+jobs:
+  test:
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v4
+      - uses: pnpm/action-setup@v2
+      - uses: actions/setup-node@v4
+        with:
+          node-version: 20
+          cache: 'pnpm'
+      
+      - run: pnpm install
+      - run: pnpm test:unit
+      - run: pnpm test:integration
+      
+  e2e:
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v4
+      - uses: pnpm/action-setup@v2
+      - run: pnpm install
+      - run: pnpm exec playwright install
+      - run: pnpm test:e2e
+```
+
+---
+
+## Quick Reference
+
+### 测试命令
+
+```bash
+pnpm test              # 运行所有测试
+pnpm test:unit         # 仅单元测试
+pnpm test:integration  # 仅集成测试
+pnpm test:e2e          # 仅 E2E 测试
+pnpm test:coverage     # 覆盖率报告
+pnpm test:watch        # 监听模式
+```
+
+### 覆盖率目标 (OPC)
+
+| 层级 | 目标 | 理由 |
+|------|------|------|
+| 工具函数 | 90%+ | 纯函数，容易测试 |
+| Hooks | 70%+ | 核心逻辑 |
+| API Routes | 80%+ | 关键入口 |
+| 组件 | 50%+ | 视觉测试成本高 |
+| E2E | 核心流程 | 不追求覆盖率 |
+
+### 推荐库
+
+```
+vitest          - 单元/集成测试
+@testing-library/react - React 组件测试
+playwright      - E2E 测试
+msw             - API mocking
+@faker-js/faker - 测试数据生成
+```

package/genes/testing-strategist/phenotype.json

@@ -0,0 +1,28 @@
+{
+  "domain": "code.testing",
+  "description": "Design testing strategies for AI and Web3 applications. Create test cases, mock data, and CI configurations. Use when writing tests, setting up test infrastructure, or when the user mentions testing, test coverage, unit test, integration test, or e2e.",
+  "inputSchema": {
+    "type": "object",
+    "properties": {
+      "prompt": {
+        "type": "string"
+      }
+    },
+    "required": []
+  },
+  "outputSchema": {
+    "type": "object",
+    "properties": {
+      "result": {
+        "type": "string"
+      }
+    }
+  },
+  "dependencies": [],
+  "version": "0.1.0",
+  "author": "rotifer-team",
+  "createdAt": 1771939409560,
+  "fidelity": "Wrapped",
+  "transparency": "Open",
+  "source": "skill"
+}

package/genes/text-summarizer/.cloud-manifest.json

@@ -0,0 +1,6 @@
+{
+  "cloud_id": "587a8430-1434-418b-b79b-7e9176ec1c96",
+  "owner": "Rotifer Protocol",
+  "version": "0.1.0",
+  "published_at": "2026-03-17T14:13:49.845Z"
+}

package/genes/text-summarizer/README.md

@@ -0,0 +1,34 @@
+# text-summarizer
+
+A Native Gene that extracts key sentences from text to produce concise summaries.
+
+## Usage
+
+```bash
+rotifer test text-summarizer --input '{"text": "Long article content here...", "maxWords": 50}'
+```
+
+## Features
+
+- Extractive summarization using sentence scoring
+- Configurable word limit
+- Two output formats: paragraph or bullet points
+- Key phrase extraction
+- Compression ratio reporting
+
+## Input
+
+| Field | Type | Required | Description |
+|-------|------|----------|-------------|
+| `text` | string | Yes | The text to summarize |
+| `maxWords` | number | No | Maximum words (default: 100) |
+| `format` | string | No | `"paragraph"` or `"bullets"` |
+
+## Output
+
+| Field | Type | Description |
+|-------|------|-------------|
+| `summary` | string | The generated summary |
+| `wordCount` | number | Word count of summary |
+| `compressionRatio` | number | Summary/original length ratio |
+| `keyPhrases` | string[] | Extracted key phrases |

package/genes/text-summarizer/index.ts

@@ -0,0 +1,122 @@
+interface SummarizerInput {
+  text: string;
+  maxWords?: number;
+  format?: "paragraph" | "bullets";
+}
+
+interface SummarizerOutput {
+  summary: string;
+  wordCount: number;
+  compressionRatio: number;
+  keyPhrases: string[];
+}
+
+function splitSentences(text: string): string[] {
+  return text
+    .replace(/([.!?])\s+/g, "$1\n")
+    .split("\n")
+    .map((s) => s.trim())
+    .filter((s) => s.length > 0);
+}
+
+function wordCount(text: string): number {
+  return text.split(/\s+/).filter((w) => w.length > 0).length;
+}
+
+function scoreSentence(sentence: string, wordFreq: Map<string, number>, position: number, total: number): number {
+  const words = sentence.toLowerCase().split(/\s+/).filter((w) => w.length > 2);
+  if (words.length === 0) return 0;
+
+  let freqScore = 0;
+  for (const w of words) freqScore += wordFreq.get(w) || 0;
+  freqScore /= words.length;
+
+  const posScore = position < total * 0.2 ? 1.5 : position > total * 0.8 ? 1.2 : 1.0;
+  const lenPenalty = words.length > 35 ? 0.7 : words.length < 5 ? 0.8 : 1.0;
+
+  return freqScore * posScore * lenPenalty;
+}
+
+function extractKeyPhrases(text: string, topN: number): string[] {
+  const stopWords = new Set([
+    "the", "a", "an", "is", "are", "was", "were", "be", "been", "being",
+    "have", "has", "had", "do", "does", "did", "will", "would", "could",
+    "should", "may", "might", "shall", "can", "to", "of", "in", "for",
+    "on", "with", "at", "by", "from", "as", "into", "through", "during",
+    "before", "after", "above", "below", "between", "and", "but", "or",
+    "not", "no", "nor", "so", "yet", "both", "either", "neither", "each",
+    "every", "all", "any", "few", "more", "most", "other", "some", "such",
+    "than", "too", "very", "just", "about", "also", "only", "own", "same",
+    "that", "this", "these", "those", "it", "its", "they", "them", "their",
+    "we", "us", "our", "you", "your", "he", "him", "his", "she", "her",
+  ]);
+
+  const freq = new Map<string, number>();
+  const words = text.toLowerCase().replace(/[^a-z0-9\s]/g, "").split(/\s+/).filter((w) => w.length > 3 && !stopWords.has(w));
+  for (const w of words) freq.set(w, (freq.get(w) || 0) + 1);
+
+  return [...freq.entries()]
+    .sort((a, b) => b[1] - a[1])
+    .slice(0, topN)
+    .map(([w]) => w);
+}
+
+export async function express(input: SummarizerInput): Promise<SummarizerOutput> {
+  const text = (input.text || "").trim();
+  const maxWords = input.maxWords ?? 100;
+  const format = input.format ?? "paragraph";
+
+  if (!text) {
+    return { summary: "", wordCount: 0, compressionRatio: 0, keyPhrases: [] };
+  }
+
+  const originalWc = wordCount(text);
+  const sentences = splitSentences(text);
+
+  if (sentences.length <= 2 || originalWc <= maxWords) {
+    return {
+      summary: text,
+      wordCount: originalWc,
+      compressionRatio: 1,
+      keyPhrases: extractKeyPhrases(text, 5),
+    };
+  }
+
+  const stopWords = new Set(["the", "a", "an", "is", "are", "was", "were", "and", "or", "but", "in", "on", "at", "to", "for", "of", "with", "by"]);
+  const freq = new Map<string, number>();
+  const allWords = text.toLowerCase().split(/\s+/).filter((w) => w.length > 2 && !stopWords.has(w));
+  for (const w of allWords) freq.set(w, (freq.get(w) || 0) + 1);
+
+  const scored = sentences.map((s, i) => ({
+    text: s,
+    score: scoreSentence(s, freq, i, sentences.length),
+    index: i,
+  }));
+
+  scored.sort((a, b) => b.score - a.score);
+
+  const selected: typeof scored = [];
+  let currentWords = 0;
+  for (const s of scored) {
+    const wc = wordCount(s.text);
+    if (currentWords + wc > maxWords && selected.length > 0) break;
+    selected.push(s);
+    currentWords += wc;
+  }
+
+  selected.sort((a, b) => a.index - b.index);
+
+  let summary: string;
+  if (format === "bullets") {
+    summary = selected.map((s) => `- ${s.text}`).join("\n");
+  } else {
+    summary = selected.map((s) => s.text).join(" ");
+  }
+
+  return {
+    summary,
+    wordCount: wordCount(summary),
+    compressionRatio: +(wordCount(summary) / originalWc).toFixed(2),
+    keyPhrases: extractKeyPhrases(text, 5),
+  };
+}