🤖 基于 OpenClaw + Claude Code 搭建端到端研发自动化系统

# OpenClaw 配置文件示例 (openclaw.toml)
[agent]
name = "dev-team-alpha"
model = "claude-opus-4-1-20250805"
max_iterations = 50

[skills]
load_paths = [
    "./skills/",
    "~/.openclaw/skills/"
]
enabled_skills = [
    "code-generation",
    "test-automation",
    "api-design",
    "deployment-pipeline"
]

[memory]
auto_save = true
context_window = 200000
persistence = "sqlite"

[tools]
mcp_servers = [
    { name = "github", url = "https://api.github.com" },
    { name = "jira", url = "https://your-company.atlassian.net" },
    { name = "jenkins", url = "http://jenkins.internal:8080" }
]

# 安装 Claude Code（推荐方式）
# macOS / Linux / WSL
curl -fsSL https://claude.ai/install.sh | bash

# Windows PowerShell
irm https://claude.ai/install.ps1 | iex

# 使用示例
cd your-project
claude "为 auth 模块编写完整的单元测试套件，运行测试并修复所有失败用例"

# 技能安装示例
# 克隆技能仓库
git clone https://github.com/MedClaw-Org/OpenClaw-Medical-Skills.git

# 安装到工作区
cp -r OpenClaw-Medical-Skills/skills/* <your-workspace>/skills/

# 或使用 ClawHub CLI 安装单个技能
npm install -g clawhub
clawhub install <skill-slug>

# 需求分析 Agent 配置
{
  "agent_type": "requirement-analyst",
  "capabilities": [
    "speech-to-text",
    "sentiment-analysis",
    "entity-extraction",
    "priority-classification"
  ],
  "input_sources": [
    { "type": "meeting_recording", "path": "/recordings/product-review-20260310.mp3" },
    { "type": "slack_channel", "channel": "#feature-requests" },
    { "type": "customer_tickets", "system": "zendesk" }
  ],
  "output_format": "structured_requirements.json"
}

# PRD 生成 Prompt 模板
你是一位资深产品专家，请根据以下结构化需求生成完整的 PRD 文档：

## 输入需求
{structured_requirements}

## PRD 结构要求
1. **文档概述**
   - 产品愿景
   - 目标用户
   - 核心价值主张

2. **功能需求详述**
   - 用户故事（As a... I want... So that...）
   - 功能描述
   - 业务流程图
   - 原型草图描述

3. **非功能需求**
   - 性能指标
   - 安全要求
   - 兼容性要求

4. **验收标准**
   - 可测试的验收条件
   - 成功指标（KPI）

5. **风险评估**
   - 技术风险
   - 业务风险
   - 缓解措施

请使用 Markdown 格式输出，确保内容清晰、可执行。

# 架构决策 Agent 配置
{
  "agent_type": "architecture-designer",
  "decision_criteria": {
    "expected_users": ">100000",
    "data_volume": ">1TB/day",
    "latency_requirement": "<100ms",
    "team_size": "10-20",
    "budget_constraint": "medium"
  },
  "recommended_pattern": "microservices-with-event-sourcing",
  "justification": "高并发需求 + 多团队协作适合微服务，事件溯源满足审计要求"
}

# 使用 Mermaid 生成架构图
graph TB
    subgraph Client_Layer
        A[Web 客户端]
        B[Mobile App]
        C[第三方 API]
    end
    
    subgraph API_Gateway
        D[Kong/APISIX]
        E[认证鉴权]
        F[限流熔断]
    end
    
    subgraph Service_Layer
        G[用户服务]
        H[订单服务]
        I[支付服务]
        J[通知服务]
    end
    
    subgraph Data_Layer
        K[(PostgreSQL)]
        L[(MongoDB)]
        M[(Redis)]
        N[(Kafka)]
    end
    
    A --> D
    B --> D
    C --> D
    D --> G
    D --> H
    D --> I
    D --> J
    G --> K
    H --> K
    H --> L
    I --> K
    J --> M
    G --> N
    H --> N

# 数据库设计 Prompt
请根据以下业务实体设计 PostgreSQL 数据库 schema：

## 业务实体
1. **User（用户）**
   - 基本信息：用户名、邮箱、手机号
   - 认证信息：密码哈希、最后登录时间
   - 状态：激活/禁用

2. **Order（订单）**
   - 订单号、用户 ID、总金额
   - 状态：待支付/已支付/已完成/已取消
   - 时间戳：创建时间、更新时间

3. **OrderItem（订单项）**
   - 订单 ID、商品 ID、数量、单价

## 设计要求
- 遵循第三范式
- 添加适当索引
- 包含审计字段（created_at, updated_at）
- 使用 UUID 作为主键
- 添加外键约束

请输出完整的 SQL DDL 语句。

# 前端项目脚手架生成
{
  "project_name": "ecommerce-frontend",
  "framework": "nextjs-14",
  "language": "typescript",
  "ui_library": "@radix-ui/react-components",
  "styling": "tailwindcss",
  "state_management": "zustand",
  "testing": ["jest", "react-testing-library", "playwright"],
  "features": [
    "ssr",
    "image-optimization",
    "api-routes",
    "middleware-auth"
  ]
}

# 生成命令
npx create-next-app@latest ecommerce-frontend \
  --typescript \
  --tailwind \
  --eslint \
  --app \
  --src-dir

# 自动生成 Next.js 路由结构
src/
├── app/
│   ├── layout.tsx              # 根布局
│   ├── page.tsx                # 首页
│   ├── (auth)/                 # 认证相关路由组
│   │   ├── login/page.tsx
│   │   ├── register/page.tsx
│   │   └── forgot-password/page.tsx
│   ├── (dashboard)/            # 仪表盘路由组（需要登录）
│   │   ├── layout.tsx          # 仪表盘布局（含 Sidebar）
│   │   ├── dashboard/page.tsx
│   │   ├── orders/
│   │   │   ├── page.tsx        # 订单列表
│   │   │   └── [id]/page.tsx   # 订单详情
│   │   ├── products/
│   │   │   ├── page.tsx
│   │   │   └── new/page.tsx
│   │   └── settings/
│   │       ├── page.tsx
│   │       └── profile/page.tsx
│   └── api/                    # API Routes
│       ├── auth/
│       │   └── route.ts
│       └── orders/
│           └── route.ts
├── components/                 # 可复用组件
│   ├── ui/                     # 基础 UI 组件
│   ├── forms/                  # 表单组件
│   └── layouts/                # 布局组件
├── lib/                        # 工具函数
├── hooks/                      # 自定义 Hooks
└── types/                      # TypeScript 类型定义

# Zustand Store 示例
import { create } from 'zustand'
import { persist } from 'zustand/middleware'

interface CartState {
  items: CartItem[]
  addItem: (item: CartItem) => void
  removeItem: (id: string) => void
  clearCart: () => void
  total: () => number
}

export const useCartStore = create<CartState>()(
  persist(
    (set, get) => ({
      items: [],
      
      addItem: (item) => set((state) => ({
        items: [...state.items, item]
      })),
      
      removeItem: (id) => set((state) => ({
        items: state.items.filter(item => item.id !== id)
      })),
      
      clearCart: () => set({ items: [] }),
      
      total: () => get().items.reduce(
        (sum, item) => sum + item.price * item.quantity, 
        0
      )
    }),
    { name: 'cart-storage' }
  )
)

# OpenAPI 3.0 规范示例
openapi: 3.0.3
info:
  title: 电商系统 API
  version: 1.0.0
  description: 完整的电商平台 REST API
servers:
  - url: https://api.example.com/v1
    description: 生产环境
  - url: https://staging-api.example.com/v1
    description: 预发布环境

paths:
  /orders:
    get:
      summary: 获取订单列表
      tags: [Orders]
      security:
        - bearerAuth: []
      parameters:
        - name: page
          in: query
          schema:
            type: integer
            default: 1
        - name: limit
          in: query
          schema:
            type: integer
            default: 20
            maximum: 100
      responses:
        '200':
          description: 成功返回订单列表
          content:
            application/json:
              schema:
                $ref: '#/components/schemas/OrderListResponse'
    
    post:
      summary: 创建新订单
      tags: [Orders]
      requestBody:
        required: true
        content:
          application/json:
            schema:
              $ref: '#/components/schemas/CreateOrderRequest'
      responses:
        '201':
          description: 订单创建成功
          content:
            application/json:
              schema:
                $ref: '#/components/schemas/Order'

components:
  schemas:
    Order:
      type: object
      properties:
        id:
          type: string
          format: uuid
        userId:
          type: string
          format: uuid
        status:
          type: string
          enum: [pending, paid, completed, cancelled]
        totalAmount:
          type: number
          format: decimal
        createdAt:
          type: string
          format: date-time
    
    OrderListResponse:
      type: object
      properties:
        data:
          type: array
          items:
            $ref: '#/components/schemas/Order'
        pagination:
          $ref: '#/components/schemas/Pagination'
  
  securitySchemes:
    bearerAuth:
      type: http
      scheme: bearer
      bearerFormat: JWT

# 使用 Prism 启动 Mock Server
npx @stoplight/prism-cli mock path/to/openapi.yaml

# 或使用 WireMock
docker run -it --rm -p 8080:8080 \
  -v $(pwd)/mappings:/home/wiremock/mappings \
  wiremock/wiremock:latest

# Mock 数据生成脚本
import { faker } from '@faker-js/faker'

export function generateMockOrders(count: number) {
  return Array.from({ length: count }, () => ({
    id: faker.string.uuid(),
    userId: faker.string.uuid(),
    status: faker.helpers.arrayElement([
      'pending', 'paid', 'completed', 'cancelled'
    ]),
    totalAmount: faker.number.float({ min: 10, max: 1000, fractionDigits: 2 }),
    createdAt: faker.date.past().toISOString(),
    items: Array.from({ length: faker.number.int({ min: 1, max: 5 }) }, () => ({
      productId: faker.string.uuid(),
      quantity: faker.number.int({ min: 1, max: 10 }),
      price: faker.number.float({ min: 5, max: 200 })
    }))
  }))
}

# 使用 Redoc 生成文档
npm install -g redoc-cli
redoc-cli bundle openapi.yaml -o docs/index.html

# 或使用 Docker
docker run --rm -p 8080:80 \
  -e SPEC_URL=/openapi.yaml \
  -v $(pwd)/openapi.yaml:/usr/share/nginx/html/openapi.yaml \
  redocly/redoc

# FastAPI 后端代码生成示例
from fastapi import APIRouter, Depends, HTTPException, status
from sqlalchemy.orm import Session
from typing import List
from uuid import UUID

from ..models.order import Order, OrderItem
from ..schemas.order import OrderCreate, OrderResponse, OrderListResponse
from ..database import get_db
from ..dependencies import get_current_user

router = APIRouter(prefix="/orders", tags=["orders"])

@router.get("", response_model=OrderListResponse)
async def list_orders(
    page: int = 1,
    limit: int = 20,
    db: Session = Depends(get_db),
    current_user: dict = Depends(get_current_user)
):
    """获取当前用户的订单列表"""
    offset = (page - 1) * limit
    
    query = db.query(Order).filter(Order.user_id == current_user["id"])
    total = query.count()
    orders = query.offset(offset).limit(limit).all()
    
    return OrderListResponse(
        data=[OrderResponse.from_orm(order) for order in orders],
        pagination={
            "page": page,
            "limit": limit,
            "total": total
        }
    )

@router.post("", response_model=OrderResponse, status_code=status.HTTP_201_CREATED)
async def create_order(
    order_data: OrderCreate,
    db: Session = Depends(get_db),
    current_user: dict = Depends(get_current_user)
):
    """创建新订单"""
    order = Order(
        user_id=current_user["id"],
        status="pending",
        total_amount=sum(item.price * item.quantity for item in order_data.items)
    )
    
    db.add(order)
    db.flush()
    
    for item_data in order_data.items:
        order_item = OrderItem(
            order_id=order.id,
            product_id=item_data.product_id,
            quantity=item_data.quantity,
            price=item_data.price
        )
        db.add(order_item)
    
    db.commit()
    db.refresh(order)
    
    return OrderResponse.from_orm(order)

# React 订单列表组件生成
'use client'

import { useState, useEffect } from 'react'
import { useQuery } from '@tanstack/react-query'
import { OrderCard } from './OrderCard'
import { Pagination } from '@/components/ui/Pagination'
import { api } from '@/lib/api'
import type { Order } from '@/types/order'

interface OrderListProps {
  initialPage?: number
}

export function OrderList({ initialPage = 1 }: OrderListProps) {
  const [page, setPage] = useState(initialPage)
  const limit = 20

  const { data, isLoading, error } = useQuery({
    queryKey: ['orders', page, limit],
    queryFn: () => api.orders.list({ page, limit }),
  })

  if (isLoading) {
    return <div className="loading-spinner">Loading...</div>
  }

  if (error) {
    return <div className="error-message">Failed to load orders</div>
  }

  return (
    <div className="order-list-container">
      <h1>My Orders</h1>
      
      <div className="orders-grid">
        {data?.data.map((order: Order) => (
          <OrderCard key={order.id} order={order} />
        ))}
      </div>

      {data?.pagination && (
        <Pagination
          currentPage={page}
          totalPages={Math.ceil(data.pagination.total / limit)}
          onPageChange={setPage}
        />
      )}
    </div>
  )
}

# CI 中的代码质量检查配置
name: Code Quality

on: [push, pull_request]

jobs:
  lint:
    runs-on: ubuntu-latest
    steps:
      - uses: actions/checkout@v4
      
      - name: Setup Node.js
        uses: actions/setup-node@v4
        with:
          node-version: '20'
      
      - name: Install dependencies
        run: npm ci
      
      - name: Run ESLint
        run: npm run lint
      
      - name: Run TypeScript check
        run: npm run type-check
      
      - name: Run Prettier check
        run: npm run format:check
      
      - name: Run SonarQube scan
        uses: SonarSource/sonarqube-scan-action@v4
        env:
          SONAR_TOKEN: ${{ secrets.SONAR_TOKEN }}
          SONAR_HOST_URL: ${{ secrets.SONAR_HOST_URL }}

# Jest 单元测试示例（自动生成）
import { calculateOrderTotal } from '../utils/orderCalculator'
import { DiscountType } from '../../types'

describe('calculateOrderTotal', () => {
  describe('正常场景', () => {
    test('应该正确计算无折扣订单总价', () => {
      const items = [
        { price: 100, quantity: 2 },
        { price: 50, quantity: 3 }
      ]
      
      const result = calculateOrderTotal(items, [])
      
      expect(result).toBe(350)
    })

    test('应该正确应用百分比折扣', () => {
      const items = [{ price: 100, quantity: 2 }]
      const discounts = [{ type: DiscountType.PERCENTAGE, value: 20 }]
      
      const result = calculateOrderTotal(items, discounts)
      
      expect(result).toBe(160) // 200 * 0.8
    })

    test('应该正确应用固定金额折扣', () => {
      const items = [{ price: 100, quantity: 2 }]
      const discounts = [{ type: DiscountType.FIXED, value: 50 }]
      
      const result = calculateOrderTotal(items, discounts)
      
      expect(result).toBe(150) // 200 - 50
    })
  })

  describe('边界条件', () => {
    test('空订单应该返回 0', () => {
      expect(calculateOrderTotal([], [])).toBe(0)
    })

    test('折扣不应使总价为负', () => {
      const items = [{ price: 10, quantity: 1 }]
      const discounts = [{ type: DiscountType.FIXED, value: 50 }]
      
      const result = calculateOrderTotal(items, discounts)
      
      expect(result).toBe(0) // 最小值为 0
    })

    test('多个折扣应该正确叠加', () => {
      const items = [{ price: 100, quantity: 2 }]
      const discounts = [
        { type: DiscountType.PERCENTAGE, value: 10 },
        { type: DiscountType.FIXED, value: 20 }
      ]
      
      const result = calculateOrderTotal(items, discounts)
      
      expect(result).toBe(160) // (200 * 0.9) - 20
    })
  })

  describe('异常情况', () => {
    test('价格为负数时应抛出错误', () => {
      const items = [{ price: -10, quantity: 1 }]
      
      expect(() => calculateOrderTotal(items, [])).toThrow(
        'Price cannot be negative'
      )
    })

    test('数量为负数时应抛出错误', () => {
      const items = [{ price: 10, quantity: -1 }]
      
      expect(() => calculateOrderTotal(items, [])).toThrow(
        'Quantity cannot be negative'
      )
    })
  })
})

# Python Pytest + Faker 测试数据生成
import pytest
from faker import Faker
from datetime import datetime, timedelta

fake = Faker()

@pytest.fixture
def sample_user():
    """生成测试用户数据"""
    return {
        "id": fake.uuid4(),
        "username": fake.user_name(),
        "email": fake.email(),
        "created_at": fake.date_time_between(start_date='-1y')
    }

@pytest.fixture
def sample_orders(sample_user):
    """生成测试订单列表"""
    return [
        {
            "id": fake.uuid4(),
            "user_id": sample_user["id"],
            "status": fake.random_element(["pending", "paid", "completed"]),
            "total_amount": fake.pydecimal(left_digits=3, right_digits=2, positive=True),
            "created_at": fake.date_time_between(start_date='-30d'),
            "items": [
                {
                    "product_id": fake.uuid4(),
                    "quantity": fake.random_int(min=1, max=10),
                    "price": fake.pydecimal(left_digits=2, right_digits=2, positive=True)
                }
                for _ in range(fake.random_int(min=1, max=5))
            ]
        }
        for _ in range(10)
    ]

def test_get_recent_orders(sample_orders):
    """测试获取最近订单"""
    recent_orders = [
        order for order in sample_orders
        if order["created_at"] > datetime.now() - timedelta(days=7)
    ]
    
    assert len(recent_orders) >= 0
    assert all(order["status"] in ["pending", "paid", "completed"] for order in recent_orders)

# 覆盖率配置（.nycrc / jest.config.js）
{
  "all": true,
  "include": ["src/**/*.ts"],
  "exclude": [
    "src/**/*.test.ts",
    "src/**/*.spec.ts",
    "src/types/**",
    "src/config/**"
  ],
  "reporter": ["html", "lcov", "text-summary"],
  "check-coverage": true,
  "lines": 85,
  "functions": 85,
  "branches": 80,
  "statements": 85
}

# 运行覆盖率并生成报告
npm run test:coverage

# 查看 HTML 报告
open coverage/index.html

# Supertest API 集成测试示例
import request from 'supertest'
import { app } from '../src/app'
import { prisma } from '../src/database'

describe('Order API Integration Tests', () => {
  beforeEach(async () => {
    // 清理测试数据
    await prisma.orderItem.deleteMany()
    await prisma.order.deleteMany()
    await prisma.user.deleteMany()
    
    // 创建测试用户
    await prisma.user.create({
      data: {
        id: 'test-user-id',
        email: 'test@example.com',
        password: 'hashed_password'
      }
    })
  })

  afterAll(async () => {
    await prisma.$disconnect()
  })

  describe('POST /api/orders', () => {
    it('应该创建订单并返回 201', async () => {
      const authToken = generateTestToken('test-user-id')
      
      const response = await request(app)
        .post('/api/orders')
        .set('Authorization', `Bearer ${authToken}`)
        .send({
          items: [
            { productId: 'prod-1', quantity: 2, price: 100 },
            { productId: 'prod-2', quantity: 1, price: 50 }
          ]
        })

      expect(response.status).toBe(201)
      expect(response.body).toMatchObject({
        status: 'pending',
        totalAmount: 250
      })
      
      // 验证数据库中存在订单
      const orderInDb = await prisma.order.findFirst({
        where: { userId: 'test-user-id' }
      })
      expect(orderInDb).not.toBeNull()
    })

    it('未授权请求应该返回 401', async () => {
      const response = await request(app)
        .post('/api/orders')
        .send({ items: [] })

      expect(response.status).toBe(401)
    })
  })

  describe('GET /api/orders/:id', () => {
    it('应该获取订单详情', async () => {
      // 先创建订单
      const createdOrder = await createTestOrder()
      const authToken = generateTestToken('test-user-id')
      
      const response = await request(app)
        .get(`/api/orders/${createdOrder.id}`)
        .set('Authorization', `Bearer ${authToken}`)

      expect(response.status).toBe(200)
      expect(response.body.id).toBe(createdOrder.id)
    })
  })
})

# Testcontainers PostgreSQL 集成测试
import {
  PostgreSqlContainer,
  StartedPostgreSqlContainer
} from '@testcontainers/postgresql'
import { PrismaClient } from '@prisma/client'

let container: StartedPostgreSqlContainer
let prisma: PrismaClient

beforeAll(async () => {
  // 启动 PostgreSQL 容器
  container = await new PostgreSqlContainer()
    .withDatabase('test_db')
    .withUsername('test')
    .withPassword('test')
    .start()
  
  // 初始化 Prisma 客户端
  const connectionUri = container.getConnectionUri()
  process.env.DATABASE_URL = connectionUri
  prisma = new PrismaClient()
  await prisma.$connect()
}, { timeout: 60000 })

afterAll(async () => {
  await prisma.$disconnect()
  await container.stop()
})

test('应该成功创建和查询订单', async () => {
  // 运行数据库迁移
  await execSync('npx prisma migrate deploy')
  
  // 创建测试数据
  const user = await prisma.user.create({
    data: { email: 'test@example.com', password: 'pass' }
  })
  
  const order = await prisma.order.create({
    data: {
      userId: user.id,
      status: 'pending',
      totalAmount: 100
    }
  })
  
  // 验证数据
  const foundOrder = await prisma.order.findUnique({
    where: { id: order.id },
    include: { user: true }
  })
  
  expect(foundOrder).not.toBeNull()
  expect(foundOrder?.user.email).toBe('test@example.com')
})

# Playwright E2E 测试示例
import { test, expect } from '@playwright/test'

test.describe('订单流程 E2E 测试', () => {
  test('用户应该能够完成从浏览到下单的完整流程', async ({ page }) => {
    // 1. 访问首页
    await page.goto('http://localhost:3000')
    await expect(page).toHaveTitle(/电商平台/)

    // 2. 搜索商品
    await page.fill('[data-testid="search-input"]', '笔记本电脑')
    await page.click('[data-testid="search-button"]')
    await expect(page.locator('.product-card')).toHaveCount({ min: 1 })

    // 3. 添加到购物车
    await page.click('[data-testid="add-to-cart"]:first-child')
    await expect(page.locator('[data-testid="cart-count"]'))
      .toHaveText('1')

    // 4. 登录
    await page.click('[data-testid="login-button"]')
    await page.fill('[name="email"]', 'test@example.com')
    await page.fill('[name="password"]', 'password123')
    await page.click('[type="submit"]')
    await expect(page.locator('[data-testid="user-menu"]')).toBeVisible()

    // 5. 结算下单
    await page.click('[data-testid="cart-icon"]')
    await page.click('[data-testid="checkout-button"]')
    await page.fill('[name="address"]', '测试地址 123 号')
    await page.click('[data-testid="place-order"]')

    // 6. 验证订单创建成功
    await expect(page.locator('.order-success-message')).toBeVisible()
    const orderId = await page.locator('.order-id').textContent()
    expect(orderId).toMatch(/^\w+-\w+-\w+-\w+-\w+$/)

    // 7. 查看订单详情
    await page.click('[data-testid="view-order"]')
    await expect(page.locator('.order-status')).toHaveText('待支付')
  })
})

# Jenkins Pipeline (Jenkinsfile) 示例
pipeline {
    agent {
        kubernetes {
            yaml '''
                apiVersion: v1
                kind: Pod
                spec:
                  containers:
                  - name: node
                    image: node:20-alpine
                    command:
                    - cat
                    tty: true
                  - name: docker
                    image: docker:24-dind
                    securityContext:
                      privileged: true
            '''
        }
    }
    
    environment {
        REGISTRY = 'registry.example.com'
        IMAGE_NAME = 'ecommerce-api'
        KUBECONFIG_PATH = '/var/jenkins_home/.kube/config'
    }
    
    stages {
        stage('Checkout') {
            steps {
                checkout scm
            }
        }
        
        stage('Install Dependencies') {
            steps {
                container('node') {
                    sh 'npm ci'
                }
            }
        }
        
        stage('Code Quality') {
            parallel {
                stage('Lint') {
                    steps {
                        container('node') {
                            sh 'npm run lint'
                        }
                    }
                }
                
                stage('Type Check') {
                    steps {
                        container('node') {
                            sh 'npm run type-check'
                        }
                    }
                }
                
                stage('Unit Test') {
                    steps {
                        container('node') {
                            sh 'npm run test:coverage'
                        }
                    }
                    post {
                        always {
                            publishHTML([
                                allowMissing: false,
                                alwaysLinkToLastBuild: true,
                                keepAll: true,
                                reportDir: 'coverage',
                                reportFiles: 'index.html',
                                reportName: 'Coverage Report'
                            ])
                        }
                    }
                }
            }
        }
        
        stage('Build Docker Image') {
            steps {
                container('docker') {
                    script {
                        docker.build("${REGISTRY}/${IMAGE_NAME}:${BUILD_ID}")
                    }
                }
            }
        }
        
        stage('Push to Registry') {
            steps {
                container('docker') {
                    script {
                        docker.withRegistry("https://${REGISTRY}", 'registry-credentials') {
                            docker.image("${REGISTRY}/${IMAGE_NAME}:${BUILD_ID}").push()
                            docker.image("${REGISTRY}/${IMAGE_NAME}:${BUILD_ID}").push('latest')
                        }
                    }
                }
            }
        }
        
        stage('Deploy to Staging') {
            steps {
                container('node') {
                    sh '''
                        kubectl --namespace staging set image deployment/api \
                          api=${REGISTRY}/${IMAGE_NAME}:${BUILD_ID}
                        kubectl --namespace staging rollout status deployment/api
                    '''
                }
            }
        }
        
        stage('Integration Test') {
            steps {
                container('node') {
                    sh 'npm run test:integration -- --baseUrl=http://staging-api:8080'
                }
            }
        }
        
        stage('Deploy to Production') {
            when {
                branch 'main'
            }
            steps {
                input {
                    message 'Deploy to production?'
                    ok 'Yes, deploy!'
                }
                container('node') {
                    sh '''
                        kubectl --namespace production set image deployment/api \
                          api=${REGISTRY}/${IMAGE_NAME}:${BUILD_ID}
                        kubectl --namespace production rollout status deployment/api
                    '''
                }
            }
        }
    }
    
    post {
        always {
            cleanWs()
        }
        success {
            echo 'Deployment successful! 🎉'
        }
        failure {
            echo 'Deployment failed! Please check logs.'
            slackSend(
                channel: '#deployments',
                color: 'danger',
                message: "Deployment failed: ${env.JOB_NAME} ${env.BUILD_ID}"
            )
        }
    }
}

# Dockerfile 多阶段构建示例
# 阶段 1: 构建阶段
FROM node:20-alpine AS builder

WORKDIR /app

# 复制 package 文件并安装依赖
COPY package*.json ./
RUN npm ci --only=production

# 复制源代码并构建
COPY . .
RUN npm run build

# 阶段 2: 生产阶段
FROM node:20-alpine AS production

# 创建非 root 用户
RUN addgroup -g 1001 -S nodejs && \
    adduser -S nextjs -u 1001

WORKDIR /app

# 从构建阶段复制文件
COPY --from=builder --chown=nextjs:nodejs /app/package*.json ./
COPY --from=builder --chown=nextjs:nodejs /app/node_modules ./node_modules
COPY --from=builder --chown=nextjs:nodejs /app/.next ./.next
COPY --from=builder --chown=nextjs:nodejs /app/public ./public

USER nextjs

EXPOSE 3000

ENV NODE_ENV=production
ENV PORT=3000

CMD ["npm", "start"]

# .dockerignore 文件
node_modules
npm-debug.log
.git
.gitignore
README.md
.env
.env.local
coverage
.next

# Kubernetes Deployment YAML
apiVersion: apps/v1
kind: Deployment
metadata:
  name: ecommerce-api
  namespace: production
  labels:
    app: ecommerce-api
    version: v1
spec:
  replicas: 3
  selector:
    matchLabels:
      app: ecommerce-api
  strategy:
    type: RollingUpdate
    rollingUpdate:
      maxSurge: 1
      maxUnavailable: 0
  template:
    metadata:
      labels:
        app: ecommerce-api
        version: v1
      annotations:
        prometheus.io/scrape: "true"
        prometheus.io/port: "3000"
    spec:
      containers:
      - name: api
        image: registry.example.com/ecommerce-api:latest
        ports:
        - containerPort: 3000
          name: http
        env:
        - name: NODE_ENV
          value: "production"
        - name: DATABASE_URL
          valueFrom:
            secretKeyRef:
              name: db-credentials
              key: url
        - name: JWT_SECRET
          valueFrom:
            secretKeyRef:
              name: api-secrets
              key: jwt-secret
        resources:
          requests:
            memory: "256Mi"
            cpu: "250m"
          limits:
            memory: "512Mi"
            cpu: "500m"
        livenessProbe:
          httpGet:
            path: /health
            port: 3000
          initialDelaySeconds: 30
          periodSeconds: 10
          timeoutSeconds: 5
          failureThreshold: 3
        readinessProbe:
          httpGet:
            path: /ready
            port: 3000
          initialDelaySeconds: 5
          periodSeconds: 5
          timeoutSeconds: 3
          failureThreshold: 3
        volumeMounts:
        - name: config
          mountPath: /app/config
          readOnly: true
      volumes:
      - name: config
        configMap:
          name: api-config
      affinity:
        podAntiAffinity:
          preferredDuringSchedulingIgnoredDuringExecution:
          - weight: 100
            podAffinityTerm:
              labelSelector:
                matchLabels:
                  app: ecommerce-api
              topologyKey: kubernetes.io/hostname
---
apiVersion: v1
kind: Service
metadata:
  name: ecommerce-api-service
  namespace: production
spec:
  selector:
    app: ecommerce-api
  ports:
  - protocol: TCP
    port: 80
    targetPort: 3000
  type: ClusterIP
---
apiVersion: autoscaling/v2
kind: HorizontalPodAutoscaler
metadata:
  name: ecommerce-api-hpa
  namespace: production
spec:
  scaleTargetRef:
    apiVersion: apps/v1
    kind: Deployment
    name: ecommerce-api
  minReplicas: 3
  maxReplicas: 20
  metrics:
  - type: Resource
    resource:
      name: cpu
      target:
        type: Utilization
        averageUtilization: 70
  - type: Resource
    resource:
      name: memory
      target:
        type: Utilization
        averageUtilization: 80
  behavior:
    scaleDown:
      stabilizationWindowSeconds: 300
      policies:
      - type: Percent
        value: 50
        periodSeconds: 60
    scaleUp:
      stabilizationWindowSeconds: 60
      policies:
      - type: Percent
        value: 100
        periodSeconds: 60
      - type: Pods
        value: 5
        periodSeconds: 60
      selectPolicy: Max

# 部署监控脚本
#!/bin/bash

NAMESPACE=$1
DEPLOYMENT=$2

echo "Monitoring deployment: $DEPLOYMENT in namespace: $NAMESPACE"

# 等待 rollout 完成
kubectl rollout status deployment/$DEPLOYMENT -n $NAMESPACE

# 检查 Pod 状态
kubectl get pods -n $NAMESPACE -l app=$DEPLOYMENT -o wide

# 查看最近日志
kubectl logs -n $NAMESPACE -l app=$DEPLOYMENT --tail=50

# 如果有问题，执行回滚
if [ $? -ne 0 ]; then
    echo "Deployment failed! Rolling back..."
    kubectl rollout undo deployment/$DEPLOYMENT -n $NAMESPACE
    exit 1
fi

echo "Deployment completed successfully!"

# Playwright Page Object 示例
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', { exact: true })
    this.submitButton = page.getByRole('button', { name: 'Sign In' })
    this.errorMessage = page.getByTestId('error-message')
  }

  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 expectLoginSuccess() {
    await expect(this.page).toHaveURL('/dashboard')
    await expect(this.page.getByTestId('user-menu')).toBeVisible()
  }

  async expectLoginError(message: string) {
    await expect(this.errorMessage).toContainText(message)
  }
}

export class OrderListPage {
  readonly page: Page
  readonly orderRows: Locator
  readonly searchInput: Locator
  readonly filterDropdown: Locator

  constructor(page: Page) {
    this.page = page
    this.orderRows = page.getByTestId('order-row')
    this.searchInput = page.getByPlaceholder('Search orders...')
    this.filterDropdown = page.getByTestId('status-filter')
  }

  async goto() {
    await this.page.goto('/orders')
  }

  async searchOrder(orderId: string) {
    await this.searchInput.fill(orderId)
    await this.page.waitForTimeout(500) // 等待防抖
  }

  async filterByStatus(status: string) {
    await this.filterDropdown.selectOption(status)
  }

  async getOrderCount(): Promise<number> {
    return this.orderRows.count()
  }
}

# Percy 视觉测试集成
import { test, expect } from '@playwright/test'
import percySnapshot from '@percy/playwright'

test.describe('Visual Regression Tests', () => {
  test('首页应该符合设计稿', async ({ page }) => {
    await page.goto('/')
    
    // 截取全屏快照
    await percySnapshot(page, 'Homepage - Desktop', {
      widths: [1920]
    })
    
    // 移动端视图
    await page.setViewportSize({ width: 375, height: 812 })
    await percySnapshot(page, 'Homepage - Mobile', {
      widths: [375]
    })
  })

  test('订单列表页视觉测试', async ({ page }) => {
    await page.goto('/orders')
    
    // 空状态
    await percySnapshot(page, 'Order List - Empty State')
    
    // 有数据状态
    await page.waitForSelector('.order-row')
    await percySnapshot(page, 'Order List - With Data')
  })
})

# axe-core 可访问性测试
import { test, expect } from '@playwright/test'
import AxeBuilder from '@axe-core/playwright'

test.describe('Accessibility Tests', () => {
  test('首页应该没有可访问性问题', async ({ page }) => {
    await page.goto('/')
    
    const accessibilityScanResults = await new AxeBuilder({ page }).analyze()
    
    expect(accessibilityScanResults.violations).toEqual([])
  })

  test('登录表单应该可访问', async ({ page }) => {
    await page.goto('/login')
    
    const accessibilityScanResults = await new AxeBuilder({ page })
      .include('form')
      .analyze()
    
    // 只检查严重级别的问题
    const seriousViolations = accessibilityScanResults.violations.filter(
      violation => violation.impact === 'serious' || violation.impact === 'critical'
    )
    
    expect(seriousViolations).toEqual([])
  })
})

# Lighthouse CI 集成
import { test, expect } from '@playwright/test'
import lighthouse from 'lighthouse'
import * as chromeLauncher from 'chrome-launcher'

test.describe('Performance Tests', () => {
  test('首页性能指标应该达标', async ({ page }) => {
    const launchedChrome = await chromeLauncher.launch({
      chromeFlags: ['--headless']
    })

    const options = {
      logLevel: 'info',
      output: 'html',
      port: launchedChrome.port,
      onlyCategories: ['performance', 'accessibility', 'best-practices'],
      throttling: {
        cpuSlowdownMultiplier: 4,
        requestLatencyMs: 56.25,
        downloadThroughputKbps: 1474.56,
        uploadThroughputKbps: 675
      }
    }

    const runnerResult = await lighthouse('http://localhost:3000', options)

    await launchedChrome.kill()

    if (!runnerResult?.lhr) {
      throw new Error('Lighthouse did not return results')
    }

    const performanceScore = runnerResult.lhr.categories.performance.score
    expect(performanceScore).toBeGreaterThanOrEqual(0.9)

    const fcp = runnerResult.lhr.audits['first-contentful-paint'].numericValue
    expect(fcp).toBeLessThan(1500) // FCP < 1.5s

    const lcp = runnerResult.lhr.audits['largest-contentful-paint'].numericValue
    expect(lcp).toBeLessThan(2500) // LCP < 2.5s
  })
})

# Jenkins 审批流程配置
stage('Deploy to Production') {
    when {
        branch 'main'
    }
    steps {
        input {
            message '是否部署到生产环境？'
            ok '确认部署'
            submitter 'release-managers,admin'
            parameters {
                string(
                    name: 'RELEASE_NOTES',
                    defaultValue: '',
                    description: '本次发布说明'
                )
                choice(
                    name: 'DEPLOYMENT_STRATEGY',
                    choices: ['rolling', 'blue-green', 'canary'],
                    description: '部署策略'
                )
                string(
                    name: 'CANARY_PERCENTAGE',
                    defaultValue: '10',
                    description: '金丝雀发布比例 (%)'
                )
            }
        }
        
        script {
            echo "部署说明：${params.RELEASE_NOTES}"
            echo "部署策略：${params.DEPLOYMENT_STRATEGY}"
            
            if (params.DEPLOYMENT_STRATEGY == 'canary') {
                deployCanary(params.CANARY_PERCENTAGE.toInteger())
            } else {
                deployStandard()
            }
        }
    }
}

# AI 代码审查报告示例
{
  "review_id": "rev-20260313-001",
  "pull_request": "#1234",
  "summary": {
    "total_issues": 5,
    "critical": 1,
    "high": 2,
    "medium": 2,
    "low": 0
  },
  "findings": [
    {
      "severity": "CRITICAL",
      "type": "security",
      "location": "src/auth/jwt.ts:45",
      "issue": "JWT secret stored in source code",
      "recommendation": "Move to environment variable or secret manager",
      "suggested_fix": "process.env.JWT_SECRET",
      "auto_fixable": true
    },
    {
      "severity": "HIGH",
      "type": "performance",
      "location": "src/orders/service.ts:123",
      "issue": "N+1 query problem in loop",
      "recommendation": "Use batch query with IN clause",
      "estimated_impact": "Reduces DB calls from 101 to 2",
      "auto_fixable": false
    }
  ],
  "approval_status": "pending_review",
  "reviewer_actions": [
    { "action": "apply_auto_fixes", "label": "应用自动修复" },
    { "action": "request_changes", "label": "请求修改" },
    { "action": "approve", "label": "批准通过" }
  ]
}

# Agent 间消息格式示例
{
  "message_id": "msg-20260313-001",
  "timestamp": "2026-03-13T10:30:00Z",
  "sender": {
    "agent_id": "backend-dev-001",
    "agent_type": "Backend Developer Agent",
    "role": "developer"
  },
  "receiver": {
    "agent_id": "qa-engineer-001",
    "agent_type": "QA Engineer Agent",
    "role": "tester"
  },
  "message_type": "task_handoff",
  "priority": "high",
  "context": {
    "feature_id": "FEAT-1234",
    "story": "作为用户，我想要重置密码，以便在忘记密码时恢复账户",
    "status": "ready_for_testing"
  },
  "payload": {
    "code_changes": {
      "files_modified": [
        "src/auth/password_reset.ts",
        "src/email/templates/reset_password.html",
        "tests/auth/password_reset.test.ts"
      ],
      "commit_hash": "abc123def456",
      "pr_url": "https://github.com/company/project/pull/567"
    },
    "test_instructions": {
      "test_scenarios": [
        "有效邮箱发送重置链接",
        "无效邮箱返回错误",
        "重置链接过期处理",
        "密码强度验证"
      ],
      "test_data": {
        "test_email": "test+reset@example.com",
        "expiry_minutes": 30
      }
    },
    "deployment_info": {
      "environment": "staging",
      "url": "https://staging.example.com",
      "deployed_at": "2026-03-13T10:25:00Z"
    }
  },
  "expected_action": {
    "action_type": "execute_tests",
    "deadline": "2026-03-13T14:00:00Z",
    "deliverables": ["test_report", "bug_reports_if_any"]
  }
}

# Agent Orchestrator 配置
orchestrator:
  name: "rnd-orchestrator-v1"
  
  workflow_engine:
    type: "state_machine"
    max_parallel_agents: 5
    timeout_per_task: 3600
  
  agent_registry:
    - id: "product-owner-001"
      type: "Product Owner Agent"
      capabilities: ["requirements", "prioritization", "prd"]
      status: "available"
    
    - id: "backend-dev-001"
      type: "Backend Developer Agent"
      capabilities: ["api", "database", "tests"]
      status: "available"
    
    - id: "qa-engineer-001"
      type: "QA Engineer Agent"
      capabilities: ["testing", "quality", "reporting"]
      status: "available"
  
  task_scheduler:
    algorithm: "priority_based"
    queue_management:
      max_queue_size: 100
      priority_levels: ["critical", "high", "medium", "low"]