# dev-tools-setup.yml
project-setup:
  ide: cursor  # 或 VS Code + Copilot
  version-control: git
  frontend-framework: react + typescript
  backend-framework: node.js + express  # 或 python + fastapi
  database: postgresql + redis
  containerization: docker + docker-compose
  ci-cd: github actions
  documentation: mkdocs  # AI辅助文档生成
  
ai-tools:
  primary: github-copilot
  secondary: claude-3.5-sonnet  # 长上下文分析
  specialized:
    - figma-ai: UI设计
    - postgres-ai: 数据库优化
    - test-ai: 测试生成

#!/bin/bash
# setup-ai-dev-env.sh

# 1. IDE配置
echo "设置Cursor IDE..."
cat > ~/.cursor/rules/ai-assistant.md << 'EOF'
# AI助手编码规则

## 通用规则
1. 遵循TypeScript严格模式
2. 使用函数式组件（React）
3. 错误处理要完整
4. 添加JSDoc注释

## 项目特定
- 使用Tailwind CSS
- API响应标准化
- 日志使用Winston
- 测试使用Jest + React Testing Library
EOF

# 2. 项目模板生成
curl -s https://api.openai.com/v1/chat/completions \
  -H "Authorization: Bearer $OPENAI_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "model": "gpt-4",
    "messages": [{
      "role": "user",
      "content": "生成一个现代化的全栈项目结构，包含：React前端、Node.js后端、PostgreSQL数据库、Docker配置、GitHub Actions工作流"
    }]
  }' | jq '.choices[0].message.content' > project-structure.md

# 给AI的提示词模板：

## 项目背景
我们要开发一个任务管理应用，类似Trello但更轻量。

## 功能需求
1. 用户认证（注册/登录）
2. 项目管理（CRUD）
3. 任务管理（看板视图）
4. 团队协作（成员邀请）
5. 实时通知

## 技术约束
- 预算有限，需要快速上线
- 预计1000用户以内
- 需要移动端适配

## 请帮我：
1. 设计技术架构方案（3个备选）
2. 估算开发工作量（人周）
3. 识别技术风险
4. 推荐具体的库和工具

# 技术方案选择
方案一: MERN全栈 (推荐)
  - 前端: React + TypeScript + Tailwind
  - 后端: Node.js + Express + TypeScript
  - 数据库: MongoDB (开发快) + Redis (缓存)
  - 优势: 快速原型，JavaScript统一

方案二: Next.js全栈
  - 框架: Next.js 14 (App Router)
  - 数据库: PostgreSQL + Prisma
  - 优势: SEO友好，部署简单

方案三: Django + React
  - 后端: Django + Django REST
  - 前端: React独立部署
  - 优势: 管理后台快速生成

工作量估算:
  - MVP版本: 3-4人周
  - 完整功能: 8-10人周

-- 提示词：设计任务管理应用的数据模型
-- 要求：规范化设计，考虑扩展性

/*
请设计PostgreSQL数据库模式，包含：
1. 用户认证相关表
2. 项目和工作空间
3. 任务和子任务
4. 团队和权限
5. 活动和通知

要求：
- 使用UUID作为主键
- 添加创建/更新时间戳
- 考虑软删除
- 添加必要的索引
- 写一些示例查询
*/

-- 1. 用户表
CREATE TABLE users (
    id UUID PRIMARY KEY DEFAULT gen_random_uuid(),
    email VARCHAR(255) UNIQUE NOT NULL,
    username VARCHAR(100) UNIQUE NOT NULL,
    hashed_password VARCHAR(255) NOT NULL,
    avatar_url TEXT,
    is_active BOOLEAN DEFAULT true,
    email_verified BOOLEAN DEFAULT false,
    created_at TIMESTAMP WITH TIME ZONE DEFAULT CURRENT_TIMESTAMP,
    updated_at TIMESTAMP WITH TIME ZONE DEFAULT CURRENT_TIMESTAMP,
    deleted_at TIMESTAMP WITH TIME ZONE
);

CREATE INDEX idx_users_email ON users(email);
CREATE INDEX idx_users_username ON users(username);

-- 2. 项目表
CREATE TABLE projects (
    id UUID PRIMARY KEY DEFAULT gen_random_uuid(),
    name VARCHAR(200) NOT NULL,
    description TEXT,
    owner_id UUID REFERENCES users(id) ON DELETE CASCADE,
    workspace_id UUID REFERENCES workspaces(id) ON DELETE CASCADE,
    color VARCHAR(7) DEFAULT '#3b82f6',
    is_public BOOLEAN DEFAULT false,
    settings JSONB DEFAULT '{}',
    created_at TIMESTAMP WITH TIME ZONE DEFAULT CURRENT_TIMESTAMP,
    updated_at TIMESTAMP WITH TIME ZONE DEFAULT CURRENT_TIMESTAMP,
    deleted_at TIMESTAMP WITH TIME ZONE
);

-- 3. 任务表
CREATE TABLE tasks (
    id UUID PRIMARY KEY DEFAULT gen_random_uuid(),
    title VARCHAR(500) NOT NULL,
    description TEXT,
    project_id UUID REFERENCES projects(id) ON DELETE CASCADE,
    column_id UUID REFERENCES task_columns(id) ON DELETE CASCADE,
    assignee_id UUID REFERENCES users(id) ON DELETE SET NULL,
    reporter_id UUID REFERENCES users(id) ON DELETE SET NULL,
    priority VARCHAR(20) CHECK (priority IN ('low', 'medium', 'high', 'critical')),
    due_date TIMESTAMP WITH TIME ZONE,
    estimated_hours DECIMAL(5,2),
    actual_hours DECIMAL(5,2) DEFAULT 0,
    position INTEGER DEFAULT 0,
    tags TEXT[] DEFAULT '{}',
    metadata JSONB DEFAULT '{}',
    created_at TIMESTAMP WITH TIME ZONE DEFAULT CURRENT_TIMESTAMP,
    updated_at TIMESTAMP WITH TIME ZONE DEFAULT CURRENT_TIMESTAMP,
    deleted_at TIMESTAMP WITH TIME ZONE
);

CREATE INDEX idx_tasks_project_id ON tasks(project_id);
CREATE INDEX idx_tasks_assignee_id ON tasks(assignee_id);
CREATE INDEX idx_tasks_due_date ON tasks(due_date);

// 提示词：创建RESTful API，包含用户认证和任务管理
// 使用TypeScript，Express，JWT认证

import express from 'express';
import { Request, Response, NextFunction } from 'express';

// 让Copilot生成完整的认证中间件
const authenticateJWT = (req: Request, res: Response, next: NextFunction) => {
  // AI会生成完整的JWT验证逻辑
};

// 生成用户路由
const userRouter = express.Router();

// RESTful端点 - Copilot会根据注释生成完整实现
userRouter.post('/register', async (req: Request, res: Response) => {
  /*
  用户注册端点
  验证输入：email, username, password
  密码哈希处理
  生成验证token
  发送欢迎邮件
  */
});

// 生成任务路由
const taskRouter = express.Router();

taskRouter.get('/', authenticateJWT, async (req: Request, res: Response) => {
  /*
  获取用户的任务列表
  支持过滤：按项目、状态、优先级
  支持分页：page, limit
  支持排序：按创建时间、截止日期
  返回：任务数组 + 分页信息
  */
});

// 让Copilot生成Swagger/OpenAPI文档
/**
 * @swagger
 * /api/tasks:
 *   get:
 *     summary: 获取任务列表
 *     tags: [Tasks]
 *     security:
 *       - bearerAuth: []
 *     parameters:
 *       - in: query
 *         name: projectId
 *         schema:
 *           type: string
 *         description: 项目ID过滤
 *       - in: query
 *         name: status
 *         schema:
 *           type: string
 *           enum: [todo, in_progress, done]
 *     responses:
 *       200:
 *         description: 任务列表
 *         content:
 *           application/json:
 *             schema:
 *               type: object
 *               properties:
 *                 data:
 *                   type: array
 *                   items:
 *                     $ref: '#/components/schemas/Task'
 *                 pagination:
 *                   $ref: '#/components/schemas/Pagination'
 */

// TaskBoard.tsx - AI生成看板组件
// 提示词：创建类似Trello的看板组件，支持拖拽任务，使用dnd-kit

import React, { useState } from 'react';
import { DndContext, DragEndEvent, closestCorners } from '@dnd-kit/core';
import { SortableContext, verticalListSortingStrategy } from '@dnd-kit/sortable';

// AI生成的类型定义
interface Task {
  id: string;
  title: string;
  description?: string;
  assignee?: User;
  dueDate?: Date;
  priority: 'low' | 'medium' | 'high';
}

interface Column {
  id: string;
  title: string;
  tasks: Task[];
}

// 让AI生成完整的看板组件
export const TaskBoard: React.FC<{ projectId: string }> = ({ projectId }) => {
  // 状态管理 - AI会建议合适的状态结构
  const [columns, setColumns] = useState<Column[]>([
    { id: 'todo', title: '待处理', tasks: [] },
    { id: 'in-progress', title: '进行中', tasks: [] },
    { id: 'review', title: '审核中', tasks: [] },
    { id: 'done', title: '已完成', tasks: [] }
  ]);

  // AI生成拖拽处理函数
  const handleDragEnd = (event: DragEndEvent) => {
    const { active, over } = event;
    
    if (!over) return;
    
    // AI实现完整的拖拽逻辑
    // 1. 找到拖拽的任务
    // 2. 找到源列和目标列
    // 3. 更新任务位置
    // 4. 调用API更新后端
  };

  // AI生成UI布局
  return (
    <div className="flex gap-4 p-4 overflow-x-auto min-h-screen bg-gray-50">
      <DndContext
        collisionDetection={closestCorners}
        onDragEnd={handleDragEnd}
      >
        {columns.map((column) => (
          <div
            key={column.id}
            className="flex-shrink-0 w-80 bg-white rounded-lg shadow"
          >
            <div className="p-3 border-b">
              <h3 className="font-semibold text-gray-700">{column.title}</h3>
              <span className="text-sm text-gray-500">
                {column.tasks.length} 个任务
              </span>
            </div>
            
            <SortableContext
              items={column.tasks.map(t => t.id)}
              strategy={verticalListSortingStrategy}
            >
              <div className="p-2 space-y-2">
                {column.tasks.map((task) => (
                  // AI生成TaskCard组件
                  <TaskCard key={task.id} task={task} />
                ))}
              </div>
            </SortableContext>
            
            {/* AI生成"添加任务"按钮 */}
            <AddTaskButton columnId={column.id} />
          </div>
        ))}
      </DndContext>
    </div>
  );
};

// 让AI生成TaskCard组件
const TaskCard: React.FC<{ task: Task }> = ({ task }) => {
  // AI实现完整的任务卡片
  return (
    <div className="p-3 bg-white border rounded shadow-sm hover:shadow transition-shadow">
      <div className="flex justify-between items-start">
        <h4 className="font-medium text-gray-800">{task.title}</h4>
        <span className={`px-2 py-1 text-xs rounded ${
          task.priority === 'high' ? 'bg-red-100 text-red-800' :
          task.priority === 'medium' ? 'bg-yellow-100 text-yellow-800' :
          'bg-green-100 text-green-800'
        }`}>
          {task.priority === 'high' ? '高' : task.priority === 'medium' ? '中' : '低'}
        </span>
      </div>
      {/* AI继续生成其他部分 */}
    </div>
  );
};

// backend/tests/task.test.ts
// 提示词：为TaskService编写完整的测试套件，包括单元测试和集成测试

import { TaskService } from '../services/TaskService';
import { TaskRepository } from '../repositories/TaskRepository';
import { NotFoundError, ValidationError } from '../errors';

// AI生成mock数据
const mockTask = {
  id: 'task-123',
  title: '测试任务',
  description: '这是一个测试任务',
  projectId: 'project-123',
  assigneeId: 'user-123',
  priority: 'medium' as const
};

describe('TaskService', () => {
  let taskService: TaskService;
  let mockRepo: jest.Mocked<TaskRepository>;

  beforeEach(() => {
    // AI会设置完整的测试环境
    mockRepo = {
      findById: jest.fn(),
      create: jest.fn(),
      update: jest.fn(),
      delete: jest.fn(),
      findByProject: jest.fn()
    };
    
    taskService = new TaskService(mockRepo);
  });

  // AI生成测试用例
  describe('createTask', () => {
    it('应该成功创建任务并返回结果', async () => {
      // 设置mock
      mockRepo.create.mockResolvedValue(mockTask);
      
      // 执行
      const result = await taskService.createTask({
        title: '测试任务',
        projectId: 'project-123'
      });
      
      // 验证
      expect(result).toEqual(mockTask);
      expect(mockRepo.create).toHaveBeenCalledWith(
        expect.objectContaining({
          title: '测试任务',
          projectId: 'project-123'
        })
      );
    });

    it('标题为空时应该抛出验证错误', async () => {
      // AI会生成边界情况测试
      await expect(
        taskService.createTask({ title: '', projectId: 'project-123' })
      ).rejects.toThrow(ValidationError);
    });

    it('项目不存在时应该抛出错误', async () => {
      // AI模拟依赖失败的情况
      mockRepo.create.mockRejectedValue(new NotFoundError('项目不存在'));
      
      await expect(
        taskService.createTask({
          title: '测试任务',
          projectId: 'non-existent'
        })
      ).rejects.toThrow(NotFoundError);
    });
  });

  // AI生成性能测试
  describe('批量操作', () => {
    it('处理100个任务时应该在2秒内完成', async () => {
      const tasks = Array.from({ length: 100 }, (_, i) => ({
        title: `任务 ${i + 1}`,
        projectId: 'project-123'
      }));
      
      const startTime = Date.now();
      
      // 模拟批量创建
      for (const task of tasks) {
        mockRepo.create.mockResolvedValueOnce({
          ...mockTask,
          id: `task-${Date.now()}-${Math.random()}`
        });
      }
      
      const promises = tasks.map(task => taskService.createTask(task));
      await Promise.all(promises);
      
      const duration = Date.now() - startTime;
      expect(duration).toBeLessThan(2000);
    });
  });
});

// 前端测试 - AI生成React组件测试
// frontend/tests/TaskCard.test.tsx
import { render, screen, fireEvent } from '@testing-library/react';
import { TaskCard } from '../components/TaskCard';

describe('TaskCard', () => {
  const mockTask = {
    id: '1',
    title: '完成AI项目',
    description: '需要集成Copilot',
    priority: 'high' as const,
    assignee: { name: '张三', avatar: 'avatar.jpg' }
  };

  it('应该正确显示任务信息', () => {
    render(<TaskCard task={mockTask} />);
    
    expect(screen.getByText('完成AI项目')).toBeInTheDocument();
    expect(screen.getByText('需要集成Copilot')).toBeInTheDocument();
    expect(screen.getByText('张三')).toBeInTheDocument();
  });

  it('点击任务应该触发详情查看', () => {
    const onViewDetail = jest.fn();
    render(<TaskCard task={mockTask} onViewDetail={onViewDetail} />);
    
    fireEvent.click(screen.getByText('完成AI项目'));
    expect(onViewDetail).toHaveBeenCalledWith('1');
  });
});

# Dockerfile - 多阶段构建
# 提示词：为Node.js + React应用创建优化的Dockerfile

# 阶段1: 依赖安装
FROM node:18-alpine AS deps
WORKDIR /app

# AI会生成优化的依赖安装
COPY package*.json ./
RUN npm ci --only=production && \
    npm cache clean --force

# 阶段2: 构建前端
FROM node:18-alpine AS frontend-builder
WORKDIR /app/frontend
COPY frontend/package*.json ./
RUN npm ci
COPY frontend/ .
RUN npm run build && \
    rm -rf node_modules

# 阶段3: 构建后端
FROM node:18-alpine AS backend-builder
WORKDIR /app/backend
COPY backend/package*.json ./
RUN npm ci
COPY backend/ .
RUN npm run build

# 阶段4: 生产镜像
FROM node:18-alpine
WORKDIR /app

# AI会配置安全最佳实践
RUN addgroup -g 1001 -S nodejs && \
    adduser -S nodejs -u 1001

# 复制构建结果
COPY --from=deps /app/node_modules ./node_modules
COPY --from=frontend-builder /app/build ./public
COPY --from=backend-builder /app/dist ./dist
COPY backend/package.json .

# 切换用户
USER nodejs

# 健康检查
HEALTHCHECK --interval=30s --timeout=3s --start-period=5s --retries=3 \
  CMD node -e "require('http').get('http://localhost:3000/health', (r) => {r.statusCode === 200 ? process.exit(0) : process.exit(1)})"

EXPOSE 3000
CMD ["node", "dist/server.js"]

# .github/workflows/ci-cd.yml
# 提示词：创建完整的CI/CD流水线，包含测试、构建、安全扫描、部署

name: CI/CD Pipeline

on:
  push:
    branches: [ main, develop ]
  pull_request:
    branches: [ main ]

env:
  NODE_VERSION: '18'
  DOCKER_IMAGE: ghcr.io/${{ github.repository }}

jobs:
  # AI会生成完整的流水线
  test:
    runs-on: ubuntu-latest
    
    strategy:
      matrix:
        node-version: [16.x, 18.x]
    
    steps:
    - uses: actions/checkout@v3
    
    - name: Setup Node.js
      uses: actions/setup-node@v3
      with:
        node-version: ${{ matrix.node-version }}
        cache: 'npm'
        cache-dependency-path: '**/package-lock.json'
    
    - name: Install dependencies
      run: npm ci
      
    - name: Run linting
      run: npm run lint
      
    - name: Run tests
      run: npm test -- --coverage
      
    - name: Upload coverage
      uses: codecov/codecov-action@v3
      with:
        file: ./coverage/lcov.info
        
  security-scan:
    runs-on: ubuntu-latest
    needs: test
    
    steps:
    - uses: actions/checkout@v3
    
    # AI会添加安全检查
    - name: Run SAST
      uses: github/codeql-action/init@v2
      with:
        languages: javascript, typescript
        
    - name: Run dependency audit
      run: npm audit --audit-level=high
      
    - name: Run Snyk security scan
      uses: snyk/actions/node@master
      env:
        SNYK_TOKEN: ${{ secrets.SNYK_TOKEN }}
        
  build-and-push:
    runs-on: ubuntu-latest
    needs: [test, security-scan]
    if: github.ref == 'refs/heads/main'
    
    steps:
    - uses: actions/checkout@v3
    
    - name: Login to GitHub Container Registry
      uses: docker/login-action@v2
      with:
        registry: ghcr.io
        username: ${{ github.actor }}
        password: ${{ secrets.GITHUB_TOKEN }}
        
    - name: Build and push Docker image
      uses: docker/build-push-action@v4
      with:
        context: .
        push: true
        tags: |
          ${{ env.DOCKER_IMAGE }}:latest
          ${{ env.DOCKER_IMAGE }}:${{ github.sha }}
        cache-from: type=gha
        cache-to: type=gha,mode=max
        
  deploy:
    runs-on: ubuntu-latest
    needs: build-and-push
    if: github.ref == 'refs/heads/main'
    
    steps:
    - name: Deploy to production
      uses: appleboy/ssh-action@master
      with:
        host: ${{ secrets.DEPLOY_HOST }}
        username: ${{ secrets.DEPLOY_USER }}
        key: ${{ secrets.DEPLOY_KEY }}
        script: |
          cd /var/www/task-manager
          docker-compose pull
          docker-compose up -d
          docker system prune -f

// 代码审查提示模板
/**
 * AI代码审查规则：
 * 1. 检查安全漏洞
 * 2. 验证业务逻辑
 * 3. 确保一致性
 * 4. 优化性能
 */

// 给AI的PR审查提示词
const prReviewPrompt = `
请审查以下Pull Request：

PR标题：添加用户通知功能
PR描述：实现了邮件和站内信通知系统

代码变更：
${codeDiff}

请检查：
1. 安全性：是否有敏感信息泄露风险？
2. 正确性：业务逻辑是否符合需求？
3. 性能：是否有不必要的数据库查询？
4. 测试：是否覆盖了边界情况？
5. 文档：是否需要更新API文档？

请给出具体的修改建议和示例代码。
`;

// AI生成的代码审查报告示例
const aiCodeReview = {
  summary: "总体良好，有几个小问题需要修复",
  securityIssues: [
    {
      file: "services/NotificationService.ts",
      line: 45,
      issue: "硬编码了API密钥",
      suggestion: "移动到环境变量",
      fix: `- const apiKey = 'sk_live_123';
+ const apiKey = process.env.EMAIL_API_KEY;`
    }
  ],
  performanceSuggestions: [
    {
      file: "controllers/userController.ts",
      issue: "N+1查询问题",
      suggestion: "使用批量查询",
      fix: "添加eager loading或数据加载器"
    }
  ],
  missingTests: [
    "需要测试邮件发送失败的重试机制",
    "缺少并发发送的测试"
  ]
};

#!/bin/bash
# ai-troubleshoot.sh

# 使用AI分析日志
LOGS=$(tail -100 /var/log/app/error.log)

curl -X POST https://api.openai.com/v1/chat/completions \
  -H "Authorization: Bearer $OPENAI_API_KEY" \
  -H "Content-Type: application/json" \
  -d "{
    \"model\": \"gpt-4\",
    \"messages\": [{
      \"role\": \"user\",
      \"content\": \"分析以下应用错误日志，找出根本原因并提供解决方案：\n\n$LOGS\"
    }]
  }" | jq -r '.choices[0].message.content'

# AI可能输出：
"""
分析结果：
1. 主要问题：数据库连接池耗尽
2. 根本原因：连接未正确关闭
3. 影响：每个新请求都会创建新连接
4. 解决方案：
   a) 增加连接池大小（临时）
   b) 修复连接泄露（代码修复）
   c) 添加连接监控

具体修复代码：
// 在数据库配置中
pool: {
  max: 50,  // 从10增加到50
  min: 10,
  acquire: 30000,
  idle: 10000
}

// 确保每次查询后关闭连接
try {
  const result = await query(...);
  return result;
} finally {
  connection.release();
}
"""

// performance-monitor.ts
// AI生成的性能监控方案

interface PerformanceMetric {
  endpoint: string;
  responseTime: number;
  memoryUsage: number;
  errorRate: number;
  timestamp: Date;
}

class PerformanceAnalyzer {
  // AI会生成性能分析算法
  async analyzeMetrics(metrics: PerformanceMetric[]): Promise<{
    bottlenecks: string[];
    recommendations: string[];
    predictions: { [key: string]: number };
  }> {
    // AI逻辑分析性能数据
    // 1. 识别慢端点
    // 2. 分析内存泄漏模式
    // 3. 预测容量需求
    // 4. 生成优化建议
    
    return {
      bottlenecks: [
        '/api/reports/generate - 平均响应时间2.5秒',
        '数据库查询缺少索引'
      ],
      recommendations: [
        '为reports表添加复合索引 (user_id, created_at)',
        '实现报告生成的队列处理',
        '添加查询结果缓存，TTL 5分钟'
      ],
      predictions: {
        '预计3个月后用户量': 5000,
        '需要增加服务器内存': 2, // GB
        '数据库连接数需求': 75
      }
    };
  }
  
  // AI生成自动化优化代码
  async autoOptimize(): Promise<void> {
    // 基于分析结果自动优化
    // 1. 自动创建数据库索引
    // 2. 调整缓存策略
    // 3. 优化API分页
  }
}

// AI生成的监控仪表板
export const performanceDashboard = {
  metrics: [
    { name: 'API响应时间', query: 'avg_over_time(response_time[5m])' },
    { name: '错误率', query: 'rate(error_count[5m]) / rate(request_count[5m])' },
    { name: '数据库连接池', query: 'database_connections_used / database_connections_total' }
  ],
  alerts: [
    {
      condition: 'response_time > 1000',
      severity: 'warning',
      message: 'API响应时间超过1秒'
    },
    {
      condition: 'error_rate > 0.05',
      severity: 'critical',
      message: '错误率超过5%'
    }
  ]
};

// tech-debt-tracker.ts
// AI识别和跟踪技术债

interface TechnicalDebt {
  id: string;
  category: 'code-quality' | 'security' | 'performance' | 'maintainability';
  description: string;
  file: string;
  line?: number;
  severity: 'low' | 'medium' | 'high' | 'critical';
  impact: string;
  suggestedFix: string;
  estimatedEffort: number; // 人时
  discoveredAt: Date;
}

class TechDebtManager {
  async scanCodebase(): Promise<TechnicalDebt[]> {
    // AI扫描代码库发现技术债
    const debtItems: TechnicalDebt[] = [];
    
    // 使用AI分析代码问题
    const codeAnalysis = await this.aiAnalyzeCode();
    
    codeAnalysis.issues.forEach(issue => {
      debtItems.push({
        id: `td-${Date.now()}-${Math.random()}`,
        category: this.mapIssueToCategory(issue.type),
        description: issue.description,
        file: issue.file,
        line: issue.line,
        severity: this.calculateSeverity(issue),
        impact: issue.impact,
        suggestedFix: issue.suggestion,
        estimatedEffort: this.estimateEffort(issue),
        discoveredAt: new Date()
      });
    });
    
    return debtItems;
  }
  
  async prioritizeDebt(items: TechnicalDebt[]): Promise<TechnicalDebt[]> {
    // AI优先级排序算法
    return items.sort((a, b) => {
      const scoreA = this.calculatePriorityScore(a);
      const scoreB = this.calculatePriorityScore(b);
      return scoreB - scoreA; // 降序
    });
  }
  
  private calculatePriorityScore(debt: TechnicalDebt): number {
    // AI生成的优先级评分算法
    const severityWeight = {
      critical: 100,
      high: 70,
      medium: 40,
      low: 20
    };
    
    const categoryWeight = {
      security: 1.5,
      performance: 1.3,
      code-quality: 1.0,
      maintainability: 0.8
    };
    
    const impactScore = this.estimateImpact(debt.impact);
    
    return (
      severityWeight[debt.severity] *
      categoryWeight[debt.category] *
      impactScore /
      debt.estimatedEffort
    );
  }
}

// 使用示例
const manager = new TechDebtManager();
const debtItems = await manager.scanCodebase();
const prioritized = await manager.prioritizeDebt(debtItems);

// AI生成的技术债报告
console.log(`发现${debtItems.length}个技术债问题`);
console.log('高优先级问题：');
prioritized
  .filter(item => item.severity === 'high' || item.severity === 'critical')
  .slice(0, 5)
  .forEach(item => {
    console.log(`- ${item.description} (${item.file}:${item.line})`);
    console.log(`  建议修复：${item.suggestedFix}`);
    console.log(`  预计耗时：${item.estimatedEffort}小时`);
  });

# AI辅助全栈开发检查清单

## 项目启动阶段
- [ ] 用AI分析需求，生成技术方案
- [ ] AI设计数据库模式
- [ ] AI生成项目骨架代码
- [ ] AI创建初始文档

## 开发阶段
- [ ] 使用Copilot/Cursor生成业务代码
- [ ] AI生成测试用例（单元、集成、E2E）
- [ ] AI辅助代码审查
- [ ] AI优化性能关键代码

## DevOps阶段
- [ ] AI生成Docker配置文件
- [ ] AI设计CI/CD流水线
- [ ] AI设置监控告警
- [ ] AI生成部署脚本

## 维护阶段
- [ ] AI分析日志，自动排错
- [ ] AI识别技术债
- [ ] AI生成重构建议
- [ ] AI预测系统容量

## 团队协作
- [ ] AI生成代码审查意见
- [ ] AI辅助知识传递
- [ ] AI生成文档更新
- [ ] AI协助故障排查

// ai-risk-manager.ts
// AI项目风险管理

interface DevelopmentRisk {
  id: string;
  type: 'technical' | 'schedule' | 'resource' | 'security';
  description: string;
  probability: number; // 0-1
  impact: 'low' | 'medium' | 'high' | 'critical';
  mitigationPlan: string;
  owner?: string;
  status: 'identified' | 'monitoring' | 'mitigated' | 'resolved';
}

class AIRiskManager {
  async predictRisks(projectData: any): Promise<DevelopmentRisk[]> {
    // 使用AI预测项目风险
    const prompt = `
基于以下项目信息，预测可能的开发风险：
项目类型：${projectData.type}
团队规模：${projectData.teamSize}
技术栈：${projectData.techStack}
时间线：${projectData.timeline}

请识别：
1. 技术风险（新框架学习曲线等）
2. 进度风险（依赖延迟等）
3. 资源风险（人员变动等）
4. 安全风险（第三方依赖等）

为每个风险提供缓解计划。
`;
    
    // 调用AI API
    const risks = await this.callAI(prompt);
    return risks;
  }
  
  async monitorRisks(risks: DevelopmentRisk[], metrics: any): Promise<{
    updatedRisks: DevelopmentRisk[];
    newRisks: DevelopmentRisk[];
  }> {
    // AI持续监控风险状态
    // 基于项目实际进度调整风险概率
    // 发现新的风险
    
    return {
      updatedRisks: risks.map(risk => ({
        ...risk,
        probability: this.adjustProbability(risk, metrics)
      })),
      newRisks: await this.identifyNewRisks(metrics)
    };
  }
}

interface AIDevelopmentMetrics {
  // 效率指标
  codeGenerationSpeed: number; // 行/小时
  testCoverage: number; // 百分比
  bugDensity: number; // bug/千行
  
  // 质量指标
  codeReviewComments: number;
  securityIssues: number;
  performanceImprovement: number; // 百分比
  
  // 团队指标
  knowledgeTransferTime: number; // 天
  onboardingTime: number; // 天
  teamVelocity: number; // 故事点/迭代
}

class AIImpactAnalyzer {
  async measureImpact(
    beforeAI: AIDevelopmentMetrics,
    afterAI: AIDevelopmentMetrics
  ): Promise<{
    efficiencyGain: number;
    qualityImprovement: number;
    roi: number;
    recommendations: string[];
  }> {
    // AI分析AI工具的影响
    
    const efficiencyGain = (
      afterAI.codeGenerationSpeed / beforeAI.codeGenerationSpeed - 1
    ) * 100;
    
    const qualityImprovement = (
      (beforeAI.bugDensity - afterAI.bugDensity) / beforeAI.bugDensity
    ) * 100;
    
    // 计算投资回报率
    const roi = this.calculateROI(beforeAI, afterAI);
    
    // AI给出改进建议
    const recommendations = await this.generateRecommendations(
      beforeAI,
      afterAI
    );
    
    return {
      efficiencyGain,
      qualityImprovement,
      roi,
      recommendations
    };
  }
}