Skill: drip618/full-stack-architect (version 1.0.0)

--- slug: full-stack-architect name: 灵枢·AI全栈构建师 version: 1.0.0 license: MIT triggers: - 全栈开发 - 架构设计 - 代码生成 - 技术选型 - 项目开发 - 前端开发 - 后端开发 - 移动开发 - 游戏开发 - 部署上线 description: "灵枢·AI全栈构建师。v1.0专业全栈开发指导，集成Agent工作流、Vibe Coding方法论、2026最新技术栈、Harness Engineering驾驭工程（四大护栏+五大上下文模式）。覆盖前端、后端、移动应用、游戏开发、架构设计，提供最佳实践与代码模板。持续蒸馏进化，成为您可信赖的全栈开发伙伴。" --- # 灵枢·AI全栈构建师 (Full Stack Architect) v1.0 > **定位**：专业的全栈开发导师，融合2026年AI Agent工作流最佳实践与Harness Engineering（驾驭工程），为用户提供从需求到上线的全链路开发指导。 > **核心**：Agent工作流驱动 + Harness Engineering + 知识体系化 + 实战验证 + 持续蒸馏进化 > **蒸馏来源**：Claude Code Agent模式6个月生产实践 + Cursor/Windsurf/Devin工作流 + v0/Bolt.new/Lovable/Replit Agent方法论 + Vercel AI SDK + React 19/Next.js 15最佳实践 + Mitchell Hashimoto Harness Engineering --- ## 核心身份 - **角色**：AI全栈架构导师 & 知识库管理器 & Agent工作流引擎 - **首要目标**： 1. 为用户提供前端、后端、移动端、架构设计等全栈开发指导 2. 持续学习和积累新知识，完善知识库体系 3. 提供可复用的代码模板和最佳实践 4. 协助完成实际项目的设计和开发 - **核心原则**： 1. **Agent工作流驱动**：计划-执行-验证循环，每步可验证可回滚 2. **知识体系化**：建立完善的知识分类和体系 3. **实战驱动**：通过实际项目巩固知识 4. **持续蒸馏**：从全球最佳实践中深度提取方法论 5. **代码质量**：注重可维护性、可读性和性能优化 6. **安全优先**：AI生成代码必须经过安全审查 --- ## Harness Engineering 驾驭工程（四大护栏 + 五大上下文模式） ### 四大护栏（Guardrails） | 护栏 | 说明 | 具体措施 | |------|------|----------| | **范围护栏** | 防止Agent越界操作 | 明确任务边界，禁止修改无关文件；每次操作前检查是否在授权范围内 | | **质量护栏** | 确保输出质量达标 | 代码必须通过lint检查；测试覆盖率≥80%；PRD必须包含验收标准 | | **安全护栏** | 防止安全漏洞 | 禁止硬编码密钥；参数化查询；输入验证；最小权限原则 | | **回滚护栏** | 失败时安全回退 | 每步操作前记录状态；失败自动回滚到上一个检查点；保留操作日志 | ### 五大上下文模式（Context Patterns） | 模式 | 适用场景 | 实现方式 | |------|----------|----------| | **项目上下文** | 理解项目整体结构 | 读取package.json/tsconfig.json/目录结构，建立项目心智模型 | | **任务上下文** | 聚焦当前子任务 | 从PRD中提取当前用户故事，只加载相关代码文件 | | **历史上下文** | 利用已有决策 | 读取CHANGELOG/commit历史/设计文档，避免重复讨论 | | **约束上下文** | 遵守项目规范 | 读取.eslintrc/.prettierrc/CONTRIBUTING.md，自动遵循代码风格 | | **环境上下文** | 适配运行环境 | 检测Node版本/操作系统/CI环境，自动调整命令和路径 | --- ## Agent工作流（蒸馏自Claude Code 6个月生产实践） ### 核心：计划-执行-验证循环 ``` 1. 理解上下文 → 制定计划 - 读取项目结构、package.json、现有代码 - 分析需求，拆解为可独立验证的子任务 - 输出：任务分解文档 + 执行顺序 2. 执行最小可验证步骤 - 每次只改一个模块/一个文件 - 先写测试，再写实现（TDD） - 保持每次变更可独立回滚 3. 验证执行结果 - 运行单元测试 - 运行lint检查 - 手动验证关键路径 4. 通过 → 提交继续 | 失败 → 回滚重试 - 通过：git commit + 进入下一步 - 失败：分析原因，调整方案，最多重试3次 - 3次失败后：标记为阻塞，请求人工介入 5. 最大迭代15次防止无限循环 - 超过15次自动暂停，输出当前进度和阻塞点 ``` ### 三种工作模式详解 #### 模式一：知识指导模式 **触发条件**：用户询问技术选型、最佳实践、架构建议 **执行流程**： 1. 理解用户的技术背景和项目需求 2. 从19个领域知识库中检索相关最佳实践 3. 结合2026年最新技术趋势给出推荐 4. 提供对比表格和决策依据 5. 输出：技术方案文档 + 推荐理由 + 替代方案 **示例对话**： ``` 用户：我想用Next.js 15开发一个电商网站，有什么最佳实践？ 系统： 1. 分析需求：电商网站需要SSR（SEO）、动态路由（商品页）、状态管理（购物车） 2. 推荐技术栈： - Next.js 15 App Router（Server Components减少客户端JS） - Drizzle ORM + PostgreSQL（类型安全的数据层） - Zustand（轻量状态管理，比Redux减少60%样板代码） - shadcn/ui（可组合组件，Tree-shaking友好） - Stripe SDK（支付集成） 3. 架构建议： - /app/products/[id] 使用SSG + ISR（每小时revalidate） - /app/cart 使用Client Component + localStorage持久化 - /app/checkout 使用Server Action处理支付 4. 输出完整的项目初始化命令和技术选型文档 ``` #### 模式二：项目执行模式 **触发条件**：用户需要从零开发完整项目 **执行流程**： 1. Step 1-2：需求诊断 → PRD生成（含用户故事地图） 2. Step 3：架构设计（含数据库Schema、API路由设计） 3. Step 4：按用户故事逐个实现（前后端并行） 4. Step 5：代码审查 + 安全扫描 + 测试 5. Step 6：部署配置 + CI/CD流水线 6. Step 7：知识沉淀，更新知识库 **示例对话**： ``` 用户：我想开发一个任务管理应用 系统： [Step 1] 需求诊断： - 核心功能：创建任务、分类标签、截止日期、优先级、看板视图 - 用户角色：个人用户（无需多租户） - 技术偏好：React前端 + Node.js后端 [Step 2] PRD生成： - 用户故事1：作为用户，我可以创建任务并设置截止日期 - 用户故事2：作为用户，我可以用看板视图拖拽管理任务状态 - 用户故事3：作为用户，我可以按标签筛选和搜索任务 - 验收标准：每个故事包含Given-When-Then格式 [Step 3] 架构设计： - 前端：Next.js 15 + Tailwind v4 + shadcn/ui + @dnd-kit - 后端：Hono + Drizzle ORM + PostgreSQL - 部署：Vercel（前端）+ Railway（数据库） - API设计：RESTful，/api/tasks CRUD + /api/tasks/reorder [Step 4-6] 逐步实现并部署上线 ``` #### 模式三：Vibe Coding模式 **触发条件**：用户需要快速原型验证想法 **执行流程**： 1. 用户用自然语言描述想法 2. 直接生成可运行的单文件HTML/JS应用 3. 使用Tailwind CDN + 内联样式快速出效果 4. 迭代修改直到满意 5. 满意后可升级为正式项目（模式二） **示例对话**： ``` 用户：帮我做一个番茄钟计时器，要有开始/暂停/重置按钮，圆环进度条 系统：直接生成单文件HTML，包含： - 25分钟倒计时逻辑 - SVG圆环进度条动画 - 开始/暂停/重置按钮 - 完成提示音 - Tailwind CSS样式 ``` --- ## 2026最新技术栈推荐 ### 前端（2026年5月） | 技术 | 版本 | 推荐度 | 说明 | |------|------|--------|------| | React | 19 | ★★★★★ | Server Components + Actions + use() hook | | Next.js | 15 | ★★★★★ | App Router + Turbopack + Streaming SSR | | Bun | 1.2+ | ★★★★☆ | 运行时+包管理+构建，比Node.js快3-5x | | Tailwind CSS | v4 | ★★★★★ | 零配置，自动内容检测 | | shadcn/ui | latest | ★★★★★ | 可组合组件，非npm依赖 | | Vercel AI SDK | 4.x | ★★★★☆ | 构建AI应用的标准SDK | ### 后端（2026年5月） | 技术 | 版本 | 推荐度 | 说明 | |------|------|--------|------| | Hono | 4.x | ★★★★★ | 边缘优先的Web框架，多运行时 | | tRPC | v11 | ★★★★☆ | 端到端类型安全API | | Drizzle ORM | latest | ★★★★☆ | TypeScript优先，轻量SQL ORM | | PostgreSQL | 16+ | ★★★★★ | 最可靠的关系数据库 | | Lucia Auth | 3.x | ★★★★☆ | 轻量认证库 | | Zod | 3.x | ★★★★★ | TypeScript schema验证 | ### 部署（2026年5月） | 平台 | 推荐度 | 适用场景 | |------|--------|---------| | Vercel | ★★★★★ | Next.js应用首选 | | Cloudflare Workers | ★★★★☆ | 边缘计算、Hono API | | Deno Deploy | ★★★☆☆ | Deno生态应用 | --- ## 完整工作流程（7步Agent流水线） ### Step 1：需求诊断与分析 > **⚠️ 自动加载**：执行本步骤时，自动读取 `references/tech_stack_recommendations.md` 获取最新技术栈推荐 - 理解用户的开发需求 - 评估技术栈选择（基于2026最新推荐） - 确定项目复杂度 - 输出：需求摘要 + 技术栈推荐 + 项目复杂度评估 ### Step 2：PRD生成与校验 > **⚠️ 自动加载**：执行本步骤时，自动读取 `prd-modules/prd-generator.md` + `prd-modules/prd-checker.md` - 需求澄清（3-8个关键问题） - PRD结构生成（项目概述、技术栈、用户故事等） - PRD规范性校验（故事粒度、验收标准、依赖关系等） - 多轮迭代修正 - 输出：完整PRD文档 ### Step 3：架构设计与技术选型 > **⚠️ 自动加载**：执行本步骤时，自动读取 `references/` 对应领域的最佳实践文档 - 基于知识库提供最佳实践建议 - 技术栈推荐（结合2026最新趋势） - 架构设计与评审 - 输出：架构设计文档 + 目录结构 + API设计 ### Step 4：用户故事分解与执行 > **⚠️ 自动加载**：执行本步骤时，自动读取 `prd-modules/story-executor.md` + `code_snippets/` 对应技术栈代码模板 - 用户故事分解（确保粒度足够小） - 子代理并行执行（无依赖故事） - 模式沉淀与共享 - 输出：可运行代码 ### Step 5：代码质量验证 > **⚠️ 自动加载**：执行本步骤时，自动读取 `references/security_best_practices.md` + `code-generator/code_quality.py` - 代码审查（逻辑错误、安全漏洞、性能问题） - 测试覆盖率检查（目标≥80%） - 安全审查（SQL注入、XSS、硬编码密钥等） - 输出：质量报告 + 修复建议 ### Step 6：部署与上线 > **⚠️ 自动加载**：执行本步骤时，自动读取 `references/cloud_native_devops.md` - 部署配置（Vercel/Cloudflare/Docker） - CI/CD流水线 - 环境变量管理 - 输出：部署成功 + 访问URL ### Step 7：知识更新与积累 - 整理本次项目的新知识 - 更新知识库 - 完善知识体系 - 输出：知识库更新记录 --- ## Vibe Coding方法论（蒸馏自v0/Bolt.new/Lovable/Replit Agent） ### 按场景选择工具 | 场景 | 推荐工具 | 原因 | |------|---------|------| | 快速验证想法 | ChatGPT/Claude对话 | 30秒出结果，无需部署 | | 展示页面/MVP | Lovable/v0 | 页面好看，上手零门槛 | | 全栈Web App | Replit Agent/Bolt.new | 后端+数据库+部署一条龙 | | 完整项目开发 | Cursor/Trae | 理解代码库上下文，Agent模式 | | 企业内部工具 | Retool | 数据看板+API集成 | | 自动化工作流 | Pipedream | 连接Slack/Gmail/Notion/GitHub | ### Vibe Coding安全铁律 1. **绝不硬编码密钥**：所有API Key用环境变量 2. **参数化查询**：数据库查询禁止拼接用户输入 3. **安全审查必做**：AI生成代码必须经过安全审查才能部署 4. **最小权限原则**：MCP服务器/数据库连接使用只读或受限权限 --- ## 目录结构 ``` full-stack-architect/ ├── SKILL.md # 技能主文件 ├── README.md # 详细使用说明 ├── skill.json # 技能元数据 ├── assets/ # 配图资源 │ ├── fullstack-01-cover.png # 封面图 │ ├── fullstack-02-architecture.png # 架构图 │ ├── fullstack-03-usecase.png # 使用场景 │ └── fullstack-04-compare.png # 效果对比 ├── ai-models/ # AI模型引擎 ├── code-generator/ # 代码生成器 ├── code_snippets/ # 代码模板库 │ ├── react_snippets.md │ ├── vue_snippets.md │ ├── python_snippets.md │ ├── go_snippets.md │ └── nodejs_snippets.md ├── docs/ # 文档 ├── integrations/ # 集成与运行时 ├── nlp/ # NLP模块 ├── prd-modules/ # PRD系统 ├── project_examples/ # 项目实战案例 ├── references/ # 19领域知识库 ├── scripts/ # 工具脚本 ├── tech-stack/ # 技术栈推荐引擎 └── web-interface/ # Web界面 ``` ## 使用示例 ### 技术咨询 ``` 用户：我想用Next.js 15开发一个电商网站，有什么最佳实践？ 系统：提供React 19 Server Components + App Router + 状态管理 + SEO优化方案 ``` ### 完整项目开发 ``` 用户：我想开发一个任务管理应用 系统：启动7步Agent流水线，从PRD生成到部署上线 ``` ### 代码优化 ``` 用户：帮我优化这个React组件的性能 系统：分析代码，提供useMemo/useCallback优化方案 ``` ## 技术特点 1. **Agent工作流驱动**：计划-执行-验证循环 2. **Harness Engineering**：四大护栏+五大上下文模式 3. **知识体系化**：19个领域最佳实践 4. **持续蒸馏**：从全球最佳实践中深度提取方法论 5. **实战验证**：通过实际项目巩固知识 ## 快速开始 1. 描述您的开发需求或技术问题 2. 系统自动匹配工作模式 3. 获得技术指导或启动项目流程 4. 持续学习和积累新知识 --- *灵枢·AI全栈构建师 v1.0.0 | MIT License | 2026-05-25*

path: ai-models/_test_code_quality.py
content: #!/usr/bin/env python3
"""测试 code_quality 模块的独立验证脚本"""
import importlib.util
import sys
import os
from types import ModuleType

base_dir = os.path.dirname(__file__)
parent_dir = os.path.abspath(os.path.join(base_dir, '..'))

# Register proper two-level package hierarchy
# full_stack_architect (top-level) -> ai_models + code_generator (sub-packages)

fsa = ModuleType('full_stack_architect')
fsa.__path__ = [parent_dir]
fsa.__package__ = 'full_stack_architect'
sys.modules['full_stack_architect'] = fsa

ai_pkg = ModuleType('full_stack_architect.ai_models')
ai_pkg.__path__ = [os.path.join(parent_dir, 'ai-models')]
ai_pkg.__package__ = 'full_stack_architect.ai_models'
sys.modules['full_stack_architect.ai_models'] = ai_pkg

spec_cm = importlib.util.spec_from_file_location(
    'full_stack_architect.ai_models.config_manager',
    os.path.join(parent_dir, 'ai-models', 'config_manager.py')
)
mod_cm = importlib.util.module_from_spec(spec_cm)
mod_cm.__package__ = 'full_stack_architect.ai_models'
sys.modules['full_stack_architect.ai_models.config_manager'] = mod_cm
spec_cm.loader.exec_module(mod_cm)

cg_pkg = ModuleType('full_stack_architect.code_generator')
cg_pkg.__path__ = [os.path.join(parent_dir, 'code-generator')]
cg_pkg.__package__ = 'full_stack_architect.code_generator'
sys.modules['full_stack_architect.code_generator'] = cg_pkg

spec_cq = importlib.util.spec_from_file_location(
    'full_stack_architect.code_generator.code_quality',
    os.path.join(parent_dir, 'code-generator', 'code_quality.py')
)
mod_cq = importlib.util.module_from_spec(spec_cq)
mod_cq.__package__ = 'full_stack_architect.code_generator'
sys.modules['full_stack_architect.code_generator.code_quality'] = mod_cq
spec_cq.loader.exec_module(mod_cq)

checker = mod_cq.CodeQualityChecker()
print('CodeQualityChecker 初始化成功')
print('规则加载成功，语言:', list(checker.rules.keys()))

python_code = 'def factorial(n):\n    if n <= 1:\n        return n\n    else:\n        return factorial(n-1) + factorial(n-2)\n'
result = checker.check_code_quality(python_code, 'python')
print('Python 代码检查结果:', result['message'])
print('发现的问题:', result['issues'])

js_code = 'function factorial(n) {\n    if (n <= 1) {\n        return n;\n    } else {\n        return factorial(n-1) + factorial(n-2);\n    }\n}\n'
result = checker.check_code_quality(js_code, 'javascript')
print('JavaScript 代码检查结果:', result['message'])
print('发现的问题:', result['issues'])

print('\n全部测试通过!')


path: ai-models/code_generation.py
content: #!/usr/bin/env python3
"""
代码生成模块
负责生成高质量的代码
"""

import os
import json
import logging
from datetime import datetime
from .model_manager import ModelManager

# 配置日志
logging.basicConfig(level=logging.INFO, format='%(asctime)s - %(levelname)s - %(message)s')
logger = logging.getLogger(__name__)

class CodeGenerator:
    def __init__(self):
        self.model_manager = ModelManager()
        self.language_templates = {
            'python': {
                'hello_world': '''
# Python Hello World
print("Hello, World!")
''',
                'web_server': '''
# Python Web Server using Flask
from flask import Flask

app = Flask(__name__)

@app.route('/')
def hello():
    return "Hello, World!"

if __name__ == "__main__":
    app.run(debug=True)
''',
                'data_analysis': '''
# Python Data Analysis using pandas
import pandas as pd

# Read data
df = pd.read_csv('data.csv')

# Basic analysis
print(df.head())
print(df.describe())

# Filter data
filtered = df[df['value'] > 100]
print(filtered)
'''
            },
            'javascript': {
                'hello_world': '''
// JavaScript Hello World
console.log("Hello, World!");
''',
                'web_server': '''
// JavaScript Web Server using Express
const express = require('express');
const app = express();
const port = 3000;

app.get('/', (req, res) => {
  res.send('Hello, World!');
});

app.listen(port, () => {
  console.log(`Server running at http://localhost:${port}`);
});
''',
                'react_component': '''
// React Component
import React from 'react';

function HelloWorld() {
  return (
    <div>
      <h1>Hello, World!</h1>
      <p>Welcome to React</p>
    </div>
  );
}

export default HelloWorld;
'''
            },
            'go': {
                'hello_world': '''
// Go Hello World
package main

import "fmt"

func main() {
    fmt.Println("Hello, World!")
}
''',
                'web_server': '''
// Go Web Server
package main

import (
    "fmt"
    "net/http"
)

func hello(w http.ResponseWriter, r *http.Request) {
    fmt.Fprintf(w, "Hello, World!")
}

func main() {
    http.HandleFunc("/", hello)
    http.ListenAndServe(":8080", nil)
}
'''
            },
            'java': {
                'hello_world': '''
// Java Hello World
public class HelloWorld {
    public static void main(String[] args) {
        System.out.println("Hello, World!");
    }
}
''',
                'web_server': '''
// Java Web Server using Spring Boot
import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.RestController;

@SpringBootApplication
@RestController
public class Application {

    @GetMapping("/")
    public String hello() {
        return "Hello, World!";
    }

    public static void main(String[] args) {
        SpringApplication.run(Application.class, args);
    }
}
'''
            }
        }
        self.code_templates = {
            'function': '''
请生成一个{language}函数，实现以下功能：
{function_description}

要求：
1. 函数名合理
2. 参数类型明确
3. 包含适当的注释
4. 处理边界情况
5. 代码风格符合{language}标准
''',
            'class': '''
请生成一个{language}类，实现以下功能：
{class_description}

要求：
1. 类名合理
2. 包含必要的属性和方法
3. 构造函数完整
4. 包含适当的注释
5. 代码风格符合{language}标准
''',
            'module': '''
请生成一个{language}模块，实现以下功能：
{module_description}

要求：
1. 模块结构清晰
2. 包含必要的函数和类
3. 提供适当的文档
4. 处理错误情况
5. 代码风格符合{language}标准
''',
            'algorithm': '''
请生成一个{language}实现，实现以下算法：
{algorithm_description}

要求：
1. 算法实现正确
2. 时间复杂度合理
3. 包含适当的注释
4. 提供测试用例
5. 代码风格符合{language}标准
'''
        }
    
    def generate(self, prompt, model_name='default', max_tokens=2000):
        """生成代码
        
        Args:
            prompt: 提示词
            model_name: 模型名称
            max_tokens: 最大 token 数
            
        Returns:
            result: 生成结果
        """
        return self.model_manager.generate(prompt, model_name, max_tokens)
    
    def generate_from_template(self, template_name, template_vars, model_name='default', max_tokens=2000):
        """使用模板生成代码
        
        Args:
            template_name: 模板名称
            template_vars: 模板变量
            model_name: 模型名称
            max_tokens: 最大 token 数
            
        Returns:
            result: 生成结果
        """
        if template_name not in self.code_templates:
            logger.error(f"模板不存在: {template_name}")
            return "模板不存在"
        
        try:
            # 填充模板
            prompt = self.code_templates[template_name].format(**template_vars)
            # 生成代码
            result = self.generate(prompt, model_name, max_tokens)
            return result
        except Exception as e:
            logger.error(f"生成失败: {str(e)}")
            return f"生成失败: {str(e)}"
    
    def generate_function(self, language, function_description, model_name='default'):
        """生成函数
        
        Args:
            language: 编程语言
            function_description: 函数描述
            model_name: 模型名称
            
        Returns:
            code: 生成的函数代码
        """
        return self.generate_from_template(
            'function',
            {
                'language': language,
                'function_description': function_description
            },
            model_name
        )
    
    def generate_class(self, language, class_description, model_name='default'):
        """生成类
        
        Args:
            language: 编程语言
            class_description: 类描述
            model_name: 模型名称
            
        Returns:
            code: 生成的类代码
        """
        return self.generate_from_template(
            'class',
            {
                'language': language,
                'class_description': class_description
            },
            model_name
        )
    
    def generate_module(self, language, module_description, model_name='default'):
        """生成模块
        
        Args:
            language: 编程语言
            module_description: 模块描述
            model_name: 模型名称
            
        Returns:
            code: 生成的模块代码
        """
        return self.generate_from_template(
            'module',
            {
                'language': language,
                'module_description': module_description
            },
            model_name
        )
    
    def generate_algorithm(self, language, algorithm_description, model_name='default'):
        """生成算法实现
        
        Args:
            language: 编程语言
            algorithm_description: 算法描述
            model_name: 模型名称
            
        Returns:
            code: 生成的算法代码
        """
        return self.generate_from_template(
            'algorithm',
            {
                'language': language,
                'algorithm_description': algorithm_description
            },
            model_name
        )
    
    def generate_from_language_template(self, language, template_name):
        """从语言模板生成代码
        
        Args:
            language: 编程语言
            template_name: 模板名称
            
        Returns:
            code: 生成的代码
        """
        if language not in self.language_templates:
            logger.error(f"不支持的语言: {language}")
            return "不支持的语言"
        
        if template_name not in self.language_templates[language]:
            logger.error(f"模板不存在: {template_name}")
            return "模板不存在"
        
        return self.language_templates[language][template_name]
    
    def add_language_template(self, language, template_name, template_content):
        """添加语言模板
        
        Args:
            language: 编程语言
            template_name: 模板名称
            template_content: 模板内容
        """
        if language not in self.language_templates:
            self.language_templates[language] = {}
        
        self.language_templates[language][template_name] = template_content
        logger.info(f"添加语言模板成功: {language}/{template_name}")
    
    def remove_language_template(self, language, template_name):
        """删除语言模板
        
        Args:
            language: 编程语言
            template_name: 模板名称
        """
        if language in self.language_templates and template_name in self.language_templates[language]:
            del self.language_templates[language][template_name]
            logger.info(f"删除语言模板成功: {language}/{template_name}")
        else:
            logger.warning(f"模板不存在: {language}/{template_name}")
    
    def list_language_templates(self, language=None):
        """列出语言模板
        
        Args:
            language: 编程语言
            
        Returns:
            templates: 模板列表
        """
        if language:
            return list(self.language_templates.get(language, {}).keys())
        else:
            return {
                lang: list(templates.keys()) 
                for lang, templates in self.language_templates.items()
            }
    
    def list_supported_languages(self):
        """列出支持的语言
        
        Returns:
            languages: 语言列表
        """
        return list(self.language_templates.keys())

if __name__ == "__main__":
    # 测试代码生成器
    generator = CodeGenerator()
    
    # 测试语言模板
    print("测试语言模板 - Python Hello World:")
    result = generator.generate_from_language_template('python', 'hello_world')
    print(result)
    print()
    
    # 测试函数生成
    print("测试函数生成 - Python 阶乘函数:")
    result = generator.generate_function('python', '计算阶乘')
    print(result)
    print()
    
    # 测试类生成
    print("测试类生成 - Python 学生类:")
    result = generator.generate_class('python', '学生类，包含姓名、年龄和成绩属性，以及计算平均成绩的方法')
    print(result)
    print()
    
    # 测试模块生成
    print("测试模块生成 - Python 数学工具模块:")
    result = generator.generate_module('python', '数学工具模块，包含常用的数学函数如求和、平均值、标准差等')
    print(result)
    print()
    
    # 测试算法生成
    print("测试算法生成 - Python 二分查找:")
    result = generator.generate_algorithm('python', '二分查找算法，在有序数组中查找目标值')
    print(result)


path: ai-models/config/code_templates.json
content: function: 请生成一个{language}函数，实现以下功能：
{function_description}

要求：
1. 函数名合理
2. 参数类型明确
3. 包含适当的注释
4. 处理边界情况
5. 代码风格符合{language}标准

class: 请生成一个{language}类，实现以下功能：
{class_description}

要求：
1. 类名合理
2. 包含必要的属性和方法
3. 构造函数完整
4. 包含适当的注释
5. 代码风格符合{language}标准

module: 请生成一个{language}模块，实现以下功能：
{module_description}

要求：
1. 模块结构清晰
2. 包含必要的函数和类
3. 提供适当的文档
4. 处理错误情况
5. 代码风格符合{language}标准

algorithm: 请生成一个{language}实现，实现以下算法：
{algorithm_description}

要求：
1. 算法实现正确
2. 时间复杂度合理
3. 包含适当的注释
4. 提供测试用例
5. 代码风格符合{language}标准


path: ai-models/config/language_templates.json
content: {
  "python": {
    "hello_world": "# Python Hello World\nprint(\"Hello, World!\")\n",
    "web_server": "# Python Web Server using Flask\nfrom flask import Flask\n\napp = Flask(__name__)\n\[REDACTED_SECRET]('/')\ndef hello():\n    return \"Hello, World!\"\n\nif __name__ == \"__main__\":\n    app.run(debug=True)\n",
    "data_analysis": "# Python Data Analysis using pandas\nimport pandas as pd\n\n# Read data\ndf = pd.read_csv('data.csv')\n\n# Basic analysis\nprint(df.head())\nprint(df.describe())\n\n# Filter data\nfiltered = df[df['value'] > 100]\nprint(filtered)\n"
  },
  "javascript": {
    "hello_world": "// JavaScript Hello World\nconsole.log(\"Hello, World!\");\n",
    "web_server": "// JavaScript Web Server using Express\nconst express = require('express');\nconst app = express();\nconst port = 3000;\n\napp.get('/', (req, res) => {\n  res.send('Hello, World!');\n});\n\napp.listen(port, () => {\n  console.log(`Server running at http://localhost:${port}`);\n});\n",
    "react_component": "// React Component\nimport React from 'react';\n\nfunction HelloWorld() {\n  return (\n    <div>\n      <h1>Hello, World!</h1>\n      <p>Welcome to React</p>\n    </div>\n  );\n}\n\nexport default HelloWorld;\n"
  },
  "go": {
    "hello_world": "// Go Hello World\npackage main\n\nimport \"fmt\"\n\nfunc main() {\n    fmt.Println(\"Hello, World!\")\n}\n",
    "web_server": "// Go Web Server\npackage main\n\nimport (\n    \"fmt\"\n    \"net/http\"\n)\n\nfunc hello(w http.ResponseWriter, r *http.Request) {\n    fmt.Fprintf(w, \"Hello, World!\")\n}\n\nfunc main() {\n    http.HandleFunc(\"/\", hello)\n    http.ListenAndServe(\":8080\", nil)\n}\n"
  },
  "java": {
    "hello_world": "// Java Hello World\npublic class HelloWorld {\n    public static void main(String[] args) {\n        System.out.println(\"Hello, World!\");\n    }\n}\n",
    "web_server": "// Java Web Server using Spring Boot\nimport org.springframework.boot.SpringApplication;\nimport org.springframework.boot.autoconfigure.SpringBootApplication;\nimport org.springframework.web.bind.annotation.GetMapping;\nimport org.springframework.web.bind.annotation.RestController;\n\n@SpringBootApplication\n@RestController\npublic class Application {\n\n    @GetMapping(\"/\")\n    public String hello() {\n        return \"Hello, World!\";\n    }\n\n    public static void main(String[] args) {\n        SpringApplication.run(Application.class, args);\n    }\n}\n"
  }
}

path: ai-models/config/text_templates.json
content: prd_summary: 请对以下PRD文档进行总结，提取关键信息：

{prd_content}

总结应该包括：
1. 项目概述
2. 核心功能
3. 技术栈
4. 目标用户
5. 成功指标

tech_recommendation: 请根据以下项目需求，推荐合适的技术栈：

项目需求：{project_requirements}

推荐应该包括：
1. 前端技术
2. 后端技术
3. 数据库
4. 部署方案
5. 推荐理由

code_explanation: 请解释以下代码的功能和实现原理：

{code}

解释应该包括：
1. 代码的整体功能
2. 关键部分的详细说明
3. 可能的优化建议

bug_analysis: 请分析以下代码中可能存在的bug：

{code}

分析应该包括：
1. 可能的bug
2. 问题原因
3. 修复建议

documentation: 请为以下功能编写文档：

功能描述：{feature_description}

文档应该包括：
1. 功能概述
2. 使用方法
3. 参数说明
4. 示例代码
5. 注意事项


path: ai-models/config.json
content: {
  "default": {
    "type": "local",
    "name": "default",
    "description": "默认AI模型",
    "enabled": true
  }
}

path: requirements.txt
content: # 核心依赖
# 无外部依赖，纯Python实现

# 可选依赖（用于大模型调用）
# openai>=1.0.0
# anthropic>=0.18.0
# google-generativeai>=0.3.0


Security scan verdicts — ClawScan: suspicious | static analysis: suspicious | VirusTotal:  | SkillSpector: suspicious (CRITICAL)