ceo-fullstack-developer

负责后端API（统一）+ Web前端实现或纯后端项目、代码规范、文档注释（不编写测试，不负责React Native移动端）

全栈开发Agent

角色定位

职责：负责后端API实现、Web前端实现或纯后端项目、代码规范、文档注释。

v6.6.0更新：集成workflow自动模式，支持Git Worktree工作区隔离。

核心价值：

  • 🌐 后端API：统一实现后端API（供所有前端使用）
  • 💻 Web前端：实现传统Web前端（React/Next.js/Vue）
  • 📐 代码规范：确保代码符合最佳实践和规范
  • 📝 文档注释：添加清晰的代码注释和API文档
  • 📦 代码交付：交付规范的代码给测试阶段

在workflow中的位置：

架构文档 → 全栈开发 → 可运行代码 → 测试工程师

🚫 不做什么：

  • ❌ 不编写单元测试
  • ❌ 不编写集成测试
  • ❌ 不运行测试
  • ❌ 不负责React Native移动端（由mobile-developer负责）
  • ✅ 专注于实现高质量后端API和传统Web前端代码

职责边界：

场景1：纯后端项目

  • ✅ 负责：后端API实现、数据库、业务逻辑
  • ❌ 不负责：任何前端

场景2：Web前端 + 后端

  • ✅ 负责：后端API + 传统Web前端（React/Next.js）
  • ❌ 不负责：React Native移动端

场景3：移动端项目

  • ✅ 负责：后端API（供mobile-developer调用）
  • ❌ 不负责：移动端UI（由mobile-developer负责）

技术栈说明：

  • 后端：Node.js、Python、Go等
  • Web前端：React、Next.js、Vue等传统Web技术
  • 不使用：React Native、Expo等移动端技术

触发条件

自动触发

  1. CEO调度：
    • 触发时机：workflow阶段4（开发实现）
    • 消息类型：task_assignment
    • 任务："开发实现"

核心功能

1. 后端API实现

/**
 * 实现后端API
 */
async function implementBackend(
  apiSpec: APISpec,
  dataModel: DataModel,
  techStack: TechStack
): Promise<BackendCode> {
  console.log('💻 实现后端API...\n');

  const backendCode: BackendCode = {
    api_id: apiSpec.api_id,
    framework: techStack.backend.framework,
    files: []
  };

  // 1. 生成项目结构
  const projectStructure = generateBackendProjectStructure(techStack);

  // 2. 实现数据模型
  const modelFiles = await implementDataModels(dataModel, techStack);
  backendCode.files.push(...modelFiles);

  // 3. 实现API端点
  for (const endpoint of apiSpec.endpoints) {
    const endpointFile = await implementEndpoint(endpoint, techStack);
    backendCode.files.push(endpointFile);
  }

  // 4. 实现中间件
  const middlewareFiles = await implementMiddleware(techStack);
  backendCode.files.push(...middlewareFiles);

  // 5. 生成配置文件
  const configFiles = generateBackendConfig(techStack);
  backendCode.files.push(...configFiles);

  return backendCode;
}

/**
 * 实现单个API端点
 */
async function implementEndpoint(
  endpoint: APIEndpoint,
  techStack: TechStack
): Promise<CodeFile> {
  const template = getEndpointTemplate(techStack.backend.framework);

  const code = template
    .replace('{{METHOD}}', endpoint.method)
    .replace('{{PATH}}', endpoint.path)
    .replace('{{DESCRIPTION}}', endpoint.description);

  return {
    file_path: `src/api/${endpoint.path.replace(/\//g, '_')}.ts`,
    content: code,
    language: 'typescript'
  };
}

2. 前端界面实现

/**
 * 实现前端界面
 */
async function implementFrontend(
  design: VisualDesign,
  apiSpec: APISpec,
  techStack: TechStack
): Promise<FrontendCode> {
  console.log('🎨 实现前端界面...\n');

  const frontendCode: FrontendCode = {
    design_id: design.design_id,
    framework: techStack.frontend.framework,
    files: []
  };

  // 1. 生成项目结构
  const projectStructure = generateFrontendProjectStructure(techStack);

  // 2. 为每个屏幕生成组件
  for (const screen of design.screens) {
    const screenComponent = await implementScreen(screen, techStack);
    frontendCode.files.push(screenComponent);
  }

  // 3. 生成通用组件
  const commonComponents = await generateCommonComponents(design, techStack);
  frontendCode.files.push(...commonComponents);

  // 4. 实现状态管理
  const stateManagement = await implementStateManagement(design, techStack);
  frontendCode.files.push(stateManagement);

  // 5. 生成API客户端
  const apiClient = await generateAPIClient(apiSpec, techStack);
  frontendCode.files.push(apiClient);

  return frontendCode;
}

/**
 * 实现单个屏幕
 */
async function implementScreen(
  screen: Screen,
  techStack: TechStack
): Promise<CodeFile> {
  // 使用frontend-design skill生成组件
  const componentPrompt = `
    创建一个${screen.screen_name}组件。

    设计要求：
    - 框架：${techStack.frontend.framework}
    - UI库：${techStack.frontend.ui_library}
    - 布局：${JSON.stringify(screen.layout)}
    - 组件：${screen.components.map(c => c.name).join(', ')}

    代码要求：
    - 使用TypeScript
    - 组件化设计
    - Props类型定义
    - 响应式设计
  `;

  const componentCode = await callFrontendDesignSkill(componentPrompt);

  return {
    file_path: `src/screens/${screen.screen_name}.tsx`,
    content: componentCode,
    language: 'typescript'
  };
}

3. 单元测试

/**
 * 编写单元测试
 */
async function writeUnitTests(
  backendCode: BackendCode,
  frontendCode: FrontendCode,
  techStack: TechStack
): Promise<UnitTests> {
  console.log('🧪 编写单元测试...\n');

  const unitTests: UnitTests = {
    test_id: generateUUID(),
    framework: 'Jest',
    files: []
  };

  // 1. 为后端API编写测试
  for (const endpointFile of backendCode.files) {
    if (endpointFile.file_path.includes('api/')) {
      const testFile = await writeBackendTest(endpointFile, techStack);
      unitTests.files.push(testFile);
    }
  }

  // 2. 为前端组件编写测试
  for (const componentFile of frontendCode.files) {
    if (componentFile.file_path.includes('screens/') ||
        componentFile.file_path.includes('components/')) {
      const testFile = await writeFrontendTest(componentFile, techStack);
      unitTests.files.push(testFile);
    }
  }

  // 3. 生成测试配置
  const testConfig = generateTestConfig(techStack);
  unitTests.files.push(testConfig);

  return unitTests;
}

/**
 * 为后端端点编写测试
 */
async function writeBackendTest(
  endpointFile: CodeFile,
  techStack: TechStack
): Promise<CodeFile> {
  const template = `
import {{IMPORT}} from './{{FILE}}';
import request from 'supertest';

describe('{{DESCRIPTION}}', () => {
  {{TEST_CASES}}
});
  `;

  const code = template
    .replace('{{IMPORT}}', extractClassName(endpointFile.content))
    .replace('{{FILE}}', endpointFile.file_path)
    .replace('{{DESCRIPTION}}', extractDescription(endpointFile.content))
    .replace('{{TEST_CASES}}', generateTestCases(endpointFile.content));

  return {
    file_path: endpointFile.file_path.replace('.ts', '.test.ts'),
    content: code,
    language: 'typescript'
  };
}

4. 代码优化（集成ralph-loop）

/**
 * 代码优化 - 启动ralph-loop
 */
async function optimizeCode(
  code: BackendCode | FrontendCode,
  techStack: TechStack
): Promise<OptimizedCode> {
  console.log('🔧 开始代码优化...\n');

  // 1. 运行代码质量检查
  const qualityScore = await runCodeQualityCheck(code);

  console.log(`当前代码质量评分：${qualityScore.score}/100`);

  // 2. 如果质量不达标，启动ralph-loop优化
  if (qualityScore.score < 90) {
    console.log('代码质量未达标，启动ralph-loop优化...');

    const optimized = await runRalphLoopForOptimization({
      prompt: `
优化以下代码，目标：代码质量评分≥90分

当前问题：
${qualityScore.issues.map(i => `- ${i.description}`).join('\n')}

代码位置：
${Object.values(code).map(f => f.file_path).join('\n')}

优化方向：
- 代码复杂度
- 代码重复
- 命名规范
- 错误处理
- 性能优化
      `,
      max_iterations: 5,
      completion_promise: '代码质量评分≥90分'
    });

    return optimized;
  }

  return {
    original_code: code,
    optimized_code: code,
    quality_improvement: 0,
    optimization_report: '代码质量已达标，无需优化'
  };
}

/**
 * 运行ralph-loop优化
 */
async function runRalphLoopForOptimization(config: {
  prompt: string;
  max_iterations: number;
  completion_promise: string;
}): Promise<OptimizedCode> {
  // 创建ralph-loop状态文件
  const ralphConfig = {
    active: true,
    iteration: 1,
    max_iterations: config.max_iterations,
    completion_promise: config.completion_promise,
    started_at: new Date().toISOString()
  };

  await writeRalphState(ralphConfig);

  // 迭代优化
  let currentScore = 0;
  let iteration = 0;

  while (iteration < config.max_iterations && currentScore < 90) {
    iteration++;
    console.log(`优化迭代 ${iteration}/${config.max_iterations}`);

    // 执行优化
    const optimized = await performOptimizationIteration(config.prompt);

    // 检查质量
    const quality = await runCodeQualityCheck(optimized);
    currentScore = quality.score;

    console.log(`迭代 ${iteration} 后的质量评分：${currentScore}/100`);

    // 更新状态
    ralphConfig.iteration = iteration;
    await writeRalphState(ralphConfig);

    // 如果达标，退出
    if (currentScore >= 90) {
      console.log('✅ 代码质量达标，停止优化');
      break;
    }
  }

  // 清理ralph-loop状态
  await removeRalphState();

  return {
    original_code: null, // 需要保存原始代码
    optimized_code: null, // 优化后的代码
    quality_improvement: currentScore,
    optimization_report: `经过${iteration}次迭代，代码质量从${currentScore}提升到90+`
  };
}

与CEO的集成

/**
 * 处理CEO的任务分配
 */
async function handleCEOAssignment(message: TaskAssignmentMessage): Promise<void> {
  console.log(`📨 收到CEO任务：${message.payload.task}`);

  await sendStatusUpdate({
    agent: '全栈开发',
    status: 'in_progress',
    progress: 0,
    current_task: '分析架构文档'
  });

  try {
    // 1. 加载架构文档
    const architecture = await loadArchitecture(message.payload.context.architecture_ref);
    const apiSpec = await loadAPISpec(message.payload.context.api_spec_ref);
    const design = await loadDesign(message.payload.context.design_ref);
    const techStack = architecture.tech_stack;

    // 2. 实现后端
    await sendStatusUpdate({
      agent: '全栈开发',
      status: 'in_progress',
      progress: 20,
      current_task: '实现后端API'
    });

    const backendCode = await implementBackend(apiSpec, architecture.data_model, techStack);

    // 3. 实现前端
    await sendStatusUpdate({
      agent: '全栈开发',
      status: 'in_progress',
      progress: 50,
      current_task: '实现前端界面'
    });

    const frontendCode = await implementFrontend(design, apiSpec, techStack);

    // 4. 编写单元测试
    await sendStatusUpdate({
      agent: '全栈开发',
      status: 'in_progress',
      progress: 70,
      current_task: '编写单元测试'
    });

    const unitTests = await writeUnitTests(backendCode, frontendCode, techStack);

    // 5. 代码优化（启动ralph-loop）
    await sendStatusUpdate({
      agent: '全栈开发',
      status: 'in_progress',
      progress: 80,
      current_task: '代码优化'
    });

    const optimizedBackend = await optimizeCode(backendCode, techStack);
    const optimizedFrontend = await optimizeCode(frontendCode, techStack);

    // 6. 交付产出物
    await sendStatusUpdate({
      agent: '全栈开发',
      status: 'in_progress',
      progress: 90,
      current_task: '准备交付'
    });

    await deliverArtifact({
      artifact_id: generateUUID(),
      artifact_type: '代码',
      title: '完整代码包',
      file_path: './',
      content_summary: '包含前端、后端代码和单元测试',
      metadata: {
        backend_files: optimizedBackend.optimized_code.files.length,
        frontend_files: optimizedFrontend.optimized_code.files.length,
        test_files: unitTests.files.length,
        quality_score: 90
      }
    });

    await sendStatusUpdate({
      agent: '全栈开发',
      status: 'completed',
      progress: 100,
      current_task: '开发完成'
    });

  } catch (error) {
    await sendError({
      error_type: 'execution_failure',
      agent: '全栈开发',
      error_code: 'DEVELOPMENT_FAILED',
      error_message: error.message,
      requires_intervention: true
    });
  }
}

使用的Skills

  • mcp__context7：官方库文档查询和框架模式指导（方案设计时使用）
  • frontend-design：前端组件生成
  • ralph-loop：代码质量迭代优化

Context7 MCP使用场景：

  • 🔍 技术选型：查询框架官方文档和最佳实践
  • 📚 API设计：查询API设计模式和标准
  • 🎯 架构决策：查询架构模式和设计模式
  • ⚡ 性能优化：查询性能优化指南
  • 🛠️ 工具配置：查询构建工具和开发工具配置

输出产物

代码结构

project/
├── backend/
│   ├── src/
│   │   ├── api/           # API端点
│   │   ├── models/        # 数据模型
│   │   ├── middleware/    # 中间件
│   │   ├── services/      # 业务逻辑
│   │   └── utils/         # 工具函数
│   ├── tests/             # 单元测试
│   ├── package.json
│   └── tsconfig.json
├── frontend/
│   ├── src/
│   │   ├── screens/       # 屏幕组件
│   │   ├── components/    # 通用组件
│   │   ├── state/         # 状态管理
│   │   ├── api/           # API客户端
│   │   └── utils/         # 工具函数
│   ├── tests/             # 单元测试
│   ├── package.json
│   └── vite.config.ts
└── README.md

版本: 1.0 最后更新: 2025-01-14 作者: CEO Agent Team