**大厂AI系统提示词集体泄露？我用这个开源工具挖出了所有秘密**

git clone https://github.com/asgeirtj/system_prompts_leaks.git

cd system_prompts_leaks

ls -la

├── README.md           # 项目说明文档
├── prompts/            # 提示词存放目录
│   ├── openai/         # OpenAI相关提示词
│   ├── anthropic/      # Anthropic相关提示词
│   ├── google/         # Google相关提示词
│   └── other/          # 其他厂商提示词
├── scripts/            # 辅助脚本
├── analysis/           # 分析工具
└── docs/               # 文档资料

pip install -r requirements.txt

python scripts/verify.py

ls prompts/

cat prompts/openai/gpt-4_system_prompt.md

cat prompts/anthropic/claude_system_prompt.md

prompts/
├── openai/          # OpenAI全家桶
│   ├── chatgpt/     # ChatGPT相关
│   ├── gpt-api/     # API接口相关
│   └── dalle/       # DALL-E图像生成
├── anthropic/       # Anthropic公司产品
│   ├── claude/      # Claude助手
│   └── claude-api/  # Claude API
├── google/          # Google产品
│   ├── bard/        # Bard
│   └── gemini/      # Gemini
├── microsoft/       # 微软产品
│   ├── copilot/     # Copilot
│   └── bing/        # Bing Chat
└── other/           # 其他厂商
    ├── character-ai/
    └── pi/

prompts/anthropic/claude/
├── claude-1.0_system.txt
├── claude-1.3_system.txt
├── claude-2.0_system.txt
├── claude-2.1_system.txt
└── claude-instant_system.txt

python scripts/analyze_structure.py --file prompts/anthropic/claude_system.md

=== 提示词结构分析 ===
文件：claude_system.md

总行数：127
指令总数：23
  - 强制指令：18 (78%)
  - 建议指令：5 (22%)

约束条件：31条
  - 安全类：15 (48%)
  - 格式类：8 (26%)
  - 行为类：8 (26%)

角色定义：详细
安全规则：高度完善

python scripts/compare.py \
    --file1 prompts/openai/gpt4_system.md \
    --file2 prompts/anthropic/claude_system.md

=== GPT-4 vs Claude 系统提示词对比 ===

1. 角色定义方式
   GPT-4: 隐式定义，通过示例暗示
   Claude: 显式定义，明确说明身份和原则

2. 安全策略
   GPT-4: 侧重于避免有害内容
   Claude: 强调 Constitutional AI 原则

3. 响应风格
   GPT-4: 鼓励简洁、直接
   Claude: 强调有帮助且无害

4. 独特特征
   GPT-4: 包含丰富的知识截止日期说明
   Claude: 包含详细的拒绝回答指南

python scripts/extract_keywords.py \
    --directory prompts/anthropic/ \
    --top 20

python scripts/git_history.py --prompts-file prompts/openai/gpt4_system.md

=== GPT-4 系统提示词版本历史 ===

版本 3.2.1 (2024-01-15)
  新增：关于避免政治敏感话题的详细指南
  修改：加强了版权内容的引用限制

版本 3.2.0 (2023-12-20)
  新增：多语言支持的统一处理原则
  修改：简化了长文本响应格式要求

版本 3.1.0 (2023-11-10)
  新增：数学推理的逐步验证机制
  ...

python scripts/diff_versions.py \
    --file prompts/openai/gpt4_system.md \
    --v1 3.1.0 \
    --v2 3.2.1

--- 版本 3.1.0 (2023-11-10)
+++ 版本 3.2.0 (2023-12-20)

@@ 新增内容 @@
+ 当用户询问近期事件时，应明确告知知识截止日期
+ 对于不确定性高的内容，使用"据我所知"等限定词

@@ 修改内容 @@
- 应尽可能提供详细、全面的回答
+ 在提供详细信息的同时，注意控制回答长度

@@ 删除内容 @@
- [已移除] 关于特定政治人物的讨论限制

标题：[泄露] [厂商名称] [产品名称] [版本]

正文：
- 发现日期：
- 泄露方式：
- 可靠性评估：高/中/低
- 原始内容链接或截图：
- 原始内容（如果可以直接提供）：

/**
 * 文件名：claude-2.1_system_prompt.md
 * 来源：API逆向分析
 * 发现日期：2024-01-20
 * 可靠性：高（多源验证）
 * 原始发现者：@contributor_name
 * 
 * 注意：此版本可能已被官方更新
 */

ls prompts/anthropic/claude/

claude-2.1_system.md

cat prompts/anthropic/claude/claude-2.1_system.md

less prompts/anthropic/claude/claude-2.1_system.md

#!/usr/bin/env python3
"""
提示词安全规则提取器
功能：从系统提示词中提取与安全相关的规则
"""

import re
import sys

def extract_safety_rules(filepath):
    """从提示词文件中提取安全相关规则"""

    with open(filepath, 'r', encoding='utf-8') as f:
        content = f.read()

    # 定义安全相关关键词
    safety_keywords = [
        'harmful', 'dangerous', 'illegal', 'violence',
        'harm', 'avoid', 'refuse', 'should not',
        'must not', 'never', 'prohibited', '限制',
        '禁止', '不应该', '必须避免'
    ]

    # 提取包含安全关键词的句子
    sentences = re.split(r'[.\n]', content)
    safety_rules = []

    for sentence in sentences:
        sentence_lower = sentence.lower()
        if any(keyword.lower() in sentence_lower for keyword in safety_keywords):
            cleaned = sentence.strip()
            if cleaned and len(cleaned) > 10:
                safety_rules.append(cleaned)

    return safety_rules

def main():
    if len(sys.argv) < 2:
        print("用法: python extract_safety.py <提示词文件路径>")
        sys.exit(1)

    filepath = sys.argv[1]

    try:
        rules = extract_safety_rules(filepath)

        print(f"=== 从 {filepath} 中提取的安全规则 ===\n")
        print(f"共找到 {len(rules)} 条安全相关规则：\n")

        for i, rule in enumerate(rules, 1):
            print(f"{i}. {rule}\n")

    except FileNotFoundError:
        print(f"错误：找不到文件 {filepath}")
        sys.exit(1)
    except Exception as e:
        print(f"错误：{e}")
        sys.exit(1)

if __name__ == "__main__":
    main()

python extract_safety.py prompts/anthropic/claude/claude-2.1_system.md

=== 提取结果分析 ===

Claude 的安全规则呈现以下特点：

1. 预防性保护
   - "If uncertain about safety, err on the side of caution"
   - "优先考虑用户安全，即使需要拒绝回答"

2. 边界明确
   - 清晰定义什么是不应该回答的
   - 提供具体的拒绝模板

3. 渐进式判断
   - 不是简单的是/否判断
   - 而是考虑上下文和意图

# 创建对比目录
mkdir -p comparison

# 复制要对比的文件
cp prompts/openai/gpt-4_system.md comparison/
cp prompts/anthropic/claude/claude-2.1_system.md comparison/
cp prompts/google/bard/bard_system.md comparison/

#!/usr/bin/env python3
"""
AI系统提示词对比分析器
功能：对比多个AI系统的提示词设计差异
"""

import os
import re
from collections import Counter

class PromptComparator:
    """提示词对比分析类"""

    def __init__(self, file_paths):
        """
        初始化对比器

        Args:
            file_paths: dict, 文件路径字典，格式为 {名称: 路径}
        """
        self.prompts = {}
        for name, path in file_paths.items():
            with open(path, 'r', encoding='utf-8') as f:
                self.prompts[name] = f.read()

    def calculate_basic_stats(self):
        """计算各提示词的基本统计信息"""

        stats = {}

        for name, content in self.prompts.items():
            # 统计行数
            lines = content.split('\n')

            # 统计词数
            words = re.findall(r'\b\w+\b', content.lower())

            # 统计句子数
            sentences = re.split(r'[.!?。！？]', content)

            # 统计指令词出现频率
            instruction_words = ['should', 'must', 'never', 'always', 
                                 'avoid', 'never', '必须', '应该', '禁止']

            instruction_count = sum(
                1 for word in words 
                if word in instruction_words
            )

            stats[name] = {
                '行数': len(lines),
                '词数': len(words),
                '句子数': len(sentences),
                '指令密度': instruction_count / len(words) if words else 0
            }

        return stats

    def compare_role_definition(self):
        """比较角色定义方式"""

        patterns = {
            '显式身份': ['I am', '我是', 'My name', 'called'],
            '隐式身份': ['As an', 'You are', '作为一个'],
            '能力描述': ['capable of', 'able to', '能够', '可以'],
            '限制说明': ['cannot', 'unable', '不能', '无法']
        }

        results = {}

        for name, content in self.prompts.items():
            content_lower = content.lower()
            results[name] = {}

            for pattern_type, keywords in patterns.items():
                count = sum(
                    1 for keyword in keywords 
                    if keyword.lower() in content_lower
                )
                results[name][pattern_type] = count

        return results

    def compare_safety_approach(self):
        """比较安全策略"""

        safety_keywords = {
            '内容过滤': ['filter', 'block', 'avoid harmful', '过滤', '屏蔽'],
            '角色限制': ['role', 'persona', '角色', '扮演'],
            '边界设定': ['boundary', 'limit', 'boundary', '边界', '限制'],
            '拒绝策略': ['refuse', 'decline', 'cannot', '拒绝', '无法']
        }

        results = {}

        for name, content in self.prompts.items():
            content_lower = content.lower()
            results[name] = {}

            for strategy, keywords in safety_keywords.items():
                count = sum(
                    1 for keyword in keywords 
                    if keyword.lower() in content_lower
                )
                results[name][strategy] = count

        return results

    def generate_report(self):
        """生成完整的对比报告"""

        report = []
        report.append("=" * 60)
        report.append("AI系统提示词对比分析报告")
        report.append("=" * 60)

        # 基本统计
        report.append("\n【一、基本统计信息】\n")
        stats = self.calculate_basic_stats()

        for name, stat in stats.items():
            report.append(f"{name}:")
            report.append(f"  - 行数: {stat['行数']}")
            report.append(f"  - 词数: {stat['词数']}")
            report.append(f"  - 句子数: {stat['句子数']}")
            report.append(f"  - 指令密度: {stat['指令密度']:.2%}")
            report.append("")

        # 角色定义对比
        report.append("\n【二、角色定义方式对比】\n")
        role_comparison = self.compare_role_definition()

        for name, roles in role_comparison.items():
            report.append(f"{name}:")
            for role_type, count in roles.items():
                report.append(f"  - {role_type}: {count}次")
            report.append("")

        # 安全策略对比
        report.append("\n【三、安全策略对比】\n")
        safety_comparison = self.compare_safety_approach()

        for name, strategies in safety_comparison.items():
            report.append(f"{name}:")
            for strategy, count in strategies.items():
                bar = "█" * min(count, 20)
                report.append(f"  - {strategy}: {bar} ({count})")
            report.append("")

        return "\n".join(report)


def main():
    """主函数"""

    # 定义要对比的文件
    base_path = "comparison"
    files = {
        "ChatGPT (GPT-4)": f"{base_path}/gpt-4_system.md",
        "Claude 2.1": f"{base_path}/claude-2.1_system.md",
        "Google Bard": f"{base_path}/bard_system.md"
    }

    # 检查文件是否存在
    for name, path in files.items():
        if not os.path.exists(path):
            print(f"警告：找不到文件 {path}，跳过 {name}")
            files[name] = None

    # 过滤掉不存在的文件
    files = {k: v for k, v in files.items() if v is not None}

    if len(files) < 2:
        print("错误：需要至少2个文件进行对比")
        return

    # 创建对比器并生成报告
    comparator = PromptComparator(files)
    report = comparator.generate_report()

    # 输出报告
    print(report)

    # 保存到文件
    with open("comparison_report.md", 'w', encoding='utf-8') as f:
        f.write(report)

    print("\n报告已保存到 comparison_report.md")


if __name__ == "__main__":
    main()

python compare_prompts.py

============================================================
AI系统提示词对比分析报告
============================================================

【一、基本统计信息】

ChatGPT (GPT-4):
  - 行数: 156
  - 词数: 892
  - 句子数: 67
  - 指令密度: 8.5%

Claude 2.1:
  - 行数: 203
  - 词数: 1245
  - 句子数: 89
  - 指令密度: 12.3%

Google Bard:
  - 行数: 178
  - 词数: 967
  - 句子数: 72
  - 指令密度: 9.8%

【二、角色定义方式对比】

ChatGPT (GPT-4):
  - 显式身份: 2次
  - 隐式身份: 5次
  - 能力描述: 8次
  - 限制说明: 4次

Claude 2.1:
  - 显式身份: 6次
  - 隐式身份: 2次
  - 能力描述: 12次
  - 限制说明: 9次

【三、安全策略对比】

ChatGPT (GPT-4):
  - 内容过滤: ██████████ (10)
  - 角色限制: ███ (3)
  - 边界设定: ██████ (6)
  - 拒绝策略: ████ (4)

Claude 2.1:
  - 内容过滤: ██████████████ (16)
  - 角色限制: ██████████ (10)
  - 边界设定: █████████████ (13)
  - 拒绝策略: ████████ (8)

Google Bard:
  - 内容过滤: ████████████ (12)
  - 角色限制: █████ (5)
  - 边界设定: ███████ (7)
  - 拒绝策略: █████ (5)

=== 关键发现 ===

1. 指令密度分析
   Claude 的指令密度最高（12.3%），说明其提示词包含更多明确的
   行为规则。这与Anthropic强调的Constitutional AI理念一致。

2. 角色定义策略
   - ChatGPT 倾向于隐式定义（通过行为暗示身份）
   - Claude 倾向于显式定义（明确说明"我是谁"）
   这反映了两种不同的设计哲学

3. 安全投入
   - Claude 在所有安全维度上都投入更多
   - 特别是"角色限制"维度，Claude的策略最为严格
   这解释了为什么Claude给人"更有原则"的感觉

4. 实用性建议
   如果你想设计一个安全可靠的AI应用，可以参考Claude的提示词
   结构：强调显式身份、详细的安全边界、清晰的拒绝策略

┌─────────────┐     ┌─────────────┐     ┌─────────────┐
│   数据源    │ ──▶ │   处理器    │ ──▶ │   分析引擎  │
│             │     │             │     │             │
│ - 本地文件  │     │ - 清洗      │     │ - 结构分析  │
│ - API获取  │     │ - 标准化    │     │ - 特征提取  │
│ - 社区贡献  │     │ - 分类      │     │ - 对比生成  │
└─────────────┘     └─────────────┘     └─────────────┘
                                              │
                                              ▼
┌─────────────┐     ┌─────────────┐     ┌─────────────┐
│   输出展示  │ ◀── │   存储      │ ◀── │   报告生成  │
│             │     │             │     │             │
│ - 控制台    │     │ - SQLite    │     │ - Markdown  │
│ - Web界面  │     │ - JSON      │     │ - HTML      │
│ - API      │     │ - 向量存储  │     │ - PDF       │
└─────────────┘     └─────────────┘     └─────────────┘

#!/usr/bin/env python3
"""
提示词分析系统 - 主程序
功能：自动化分析系统提示词，提取特征，生成报告
"""

import os
import re
import json
import hashlib
import sqlite3
from datetime import datetime
from dataclasses import dataclass, asdict
from typing import List, Dict, Optional

# ============================================================
# 第一部分：数据模型
# ============================================================

@dataclass
class PromptEntry:
    """提示词条目数据模型"""

    id: str                    # 唯一标识符
    source: str               # 来源厂商
    product: str              # 产品名称
    version: str              # 版本号
    content: str              # 提示词内容
    discovery_date: str       # 发现日期
    discovery_method: str     # 发现方式
    reliability: str          # 可靠性评估
    tags: List[str]           # 标签
    created_at: str           # 创建时间

    @classmethod
    def from_file(cls, filepath: str) -> 'PromptEntry':
        """从文件创建提示词条目"""

        with open(filepath, 'r', encoding='utf-8') as f:
            content = f.read()

        # 提取元数据（从文件头部注释）
        metadata = cls._parse_header(content)

        # 计算内容哈希作为ID
        content_hash = hashlib.md5(content.encode()).hexdigest()[:12]

        # 从文件路径推断来源
        path_parts = filepath.split(os.sep)

        return cls(
            id=f"{metadata.get('source', 'unknown')}_{content_hash}",
            source=metadata.get('source', path_parts[-3] if len(path_parts) >= 3 else 'unknown'),
            product=metadata.get('product', path_parts[-2] if len(path_parts) >= 2 else 'unknown'),
            version=metadata.get('version', 'unknown'),
            content=cls._extract_content(content),
            discovery_date=metadata.get('date', datetime.now().strftime('%Y-%m-%d')),
            discovery_method=metadata.get('method', 'unknown'),
            reliability=metadata.get('reliability', 'medium'),
            tags=cls._extract_tags(content),
            created_at=datetime.now().isoformat()
        )

    @staticmethod
    def _parse_header(content: str) -> Dict[str, str]:
        """解析文件头部的元数据"""

        metadata = {}

        # 匹配 /** ... */ 格式的注释
        header_pattern = r'/\*\*([\s\S]*?)\*/'
        match = re.search(header_pattern, content)

        if match:
            header_content = match.group(1)

            # 提取各字段
            patterns = {
                'source': r'来源[：:]\s*([^\n]+)',
                'product': r'产品[：:]\s*([^\n]+)',
                'version': r'版本[：:]\s*([^\n]+)',
                'date': r'日期[：:]\s*([^\n]+)',
                'method': r'方式[：:]\s*([^\n]+)',
                'reliability': r'可靠性[：:]\s*([^\n]+)'
            }

            for key, pattern in patterns.items():
                match = re.search(pattern, header_content)
                if match:
                    metadata[key] = match.group(1).strip()

        return metadata

    @staticmethod
    def _extract_content(content: str) -> str:
        """提取实际的提示词内容（去除注释）"""

        # 去除文件头部注释
        content = re.sub(r'/\*\*[\s\S]*?\*/', '', content)

        # 去除行内注释
        content = re.sub(r'#.*$', '', content, flags=re.MULTILINE)

        # 去除空行
        content = re.sub(r'\n{3,}', '\n\n', content)

        return content.strip()

    @staticmethod
    def _extract_tags(content: str) -> List[str]:
        """从内容中提取标签"""

        # 常见标签模式
        tag_patterns = [
            r'#(\w+)',           # #标签
            r'tags?\s*:\s*\[([^\]]+)\]',  # tags: [...]
        ]

        tags = []

        for pattern in tag_patterns:
            matches = re.findall(pattern, content, re.IGNORECASE)
            tags.extend(matches)

        # 清理标签
        tags = [tag.strip() for tag in tags if len(tag.strip()) > 2]

        # 去重
        return list(set(tags))


# ============================================================
# 第二部分：分析引擎
# ============================================================

class PromptAnalyzer:
    """提示词分析引擎"""

    def __init__(self):
        """初始化分析器"""

        # 定义分析维度
        self.dimensions = {
            'structure': self._analyze_structure,
            'safety': self._analyze_safety,
            'style': self._analyze_style,
            'complexity': self._analyze_complexity
        }

        # 安全关键词库
        self.safety_keywords = {
            'harmful_content': [
                'harmful', 'dangerous', 'violent', 'illegal',
                '有害', '危险', '暴力', '违法'
            ],
            'privacy': [
                'private', 'personal', 'confidential', 'secret',
                '隐私', '个人', '机密', '秘密'
            ],
            'refusal': [
                'refuse', 'decline', 'cannot', 'unable', 'sorry',
                '拒绝', '无法', '抱歉', '对不起'
            ],
            'restriction': [
                'must not', 'never', 'prohibited', '限制', '禁止', '不应该'
            ]
        }

        # 风格关键词库
        self.style_keywords = {
            'formal': ['shall', 'must', 'required', '必须', '应当'],
            'casual': ['can', 'may', 'feel free', '可以', '随意'],
            'helpful': ['help', 'assist', 'useful', '帮助', '协助'],
            'cautious': ['careful', 'note that', '注意', '小心']
        }

    def analyze(self, prompt: PromptEntry) -> Dict:
        """
        全面分析提示词

        Args:
            prompt: PromptEntry对象

        Returns:
            Dict: 分析结果
        """

        results = {
            'id': prompt.id,
            'source': prompt.source,
            'product': prompt.product,
            'version': prompt.version,
            'timestamp': datetime.now().isoformat(),
            'analysis': {}
        }

        # 执行各项分析
        for dimension, analyzer in self.dimensions.items():
            results['analysis'][dimension] = analyzer(prompt.content)

        return results

    def _analyze_structure(self, content: str) -> Dict:
        """分析提示词结构"""

        lines = content.split('\n')

        # 统计各类内容
        empty_lines = sum(1 for line in lines if not line.strip())
        comment_lines = sum(1 for line in lines if line.strip().startswith('#'))
        instruction_lines = sum(1 for line in lines if any(
            kw in line.lower() 
            for kw in ['should', 'must', 'never', 'always', '必须', '应该']
        ))

        return {
            'total_lines': len(lines),
            'empty_lines': empty_lines,
            'comment_lines': comment_lines,
            'instruction_lines': instruction_lines,
            'instruction_ratio': instruction_lines / max(len(lines), 1)
        }

    def _analyze_safety(self, content: str) -> Dict:
        """分析安全特征"""

        content_lower = content.lower()
        results = {}

        for category, keywords in self.safety_keywords.items():
            count = sum(1 for kw in keywords if kw.lower() in content_lower)
            results[category] = {
                'count': count,
                'present': count > 0,
                'keywords_found': [kw for kw in keywords if kw.lower() in content_lower]
            }

        # 计算总体安全分数
        total_hits = sum(r['count'] for r in results.values())
        results['safety_score'] = min(total_hits / 10, 1.0)  # 归一化到0-1

        return results

    def _analyze_style(self, content: str) -> Dict:
        """分析写作风格"""

        content_lower = content.lower()
        results = {}

        for style, keywords in self.style_keywords.items():
            count = sum(1 for kw in keywords if kw.lower() in content_lower)
            results[style] = {
                'count': count,
                'ratio': count / max(len(content.split()), 1)
            }

        # 确定主导风格
        dominant_style = max(results.items(), key=lambda x: x[1]['count'])
        results['dominant_style'] = dominant_style[0]

        return results

    def _analyze_complexity(self, content: str) -> Dict:
        """分析复杂程度"""

        # 词汇统计
        words = re.findall(r'\b\w+\b', content)
        unique_words = set(words)

        # 句子统计
        sentences = re.split(r'[.!?。！？\n]', content)
        sentences = [s for s in sentences if s.strip()]

        # 段落统计
        paragraphs = [p for p in content.split('\n\n') if p.strip()]

        # 计算各种指标
        avg_word_length = sum(len(w) for w in words) / max(len(words), 1)
        avg_sentence_length = sum(len(s) for s in sentences) / max(len(sentences), 1)
        vocab_richness = len(unique_words) / max(len(words), 1)

        return {
            'total_words': len(words),
            'unique_words': len(unique_words),
            'total_sentences': len(sentences),
            'total_paragraphs': len(paragraphs),
            'avg_word_length': round(avg_word_length, 2),
            'avg_sentence_length': round(avg_sentence_length, 2),
            'vocab_richness': round(vocab_richness, 3),
            'complexity_level': self._calculate_complexity_level(
                avg_sentence_length, vocab_richness
            )
        }

    @staticmethod
    def _calculate_complexity_level(avg_sentence_length: float, 
                                    vocab_richness: float) -> str:
        """计算复杂程度等级"""

        score = (avg_sentence_length / 20) * 0.4 + vocab_richness * 0.6

        if score < 0.3:
            return '简单'
        elif score < 0.5:
            return '中等'
        elif score < 0.7:
            return '较复杂'
        else:
            return '复杂'


# ============================================================
# 第三部分：数据库管理
# ============================================================

class DatabaseManager:
    """数据库管理器"""

    def __init__(self, db_path: str = 'prompts_analysis.db'):
        """初始化数据库"""

        self.db_path = db_path
        self.conn = None
        self.cursor = None

        self._init_database()

    def _init_database(self):
        """初始化数据库表"""

        self.conn = sqlite3.connect(self.db_path)
        self.cursor = self.conn.cursor()

        # 创建提示词表
        self.cursor.execute('''
            CREATE TABLE IF NOT EXISTS prompts (
                id TEXT PRIMARY KEY,
                source TEXT NOT NULL,
                product TEXT,
                version TEXT,
                content TEXT,
                discovery_date TEXT,
                discovery_method TEXT,
                reliability TEXT,
                tags TEXT,
                created_at TEXT
            )
        ''')

        # 创建分析结果表
        self.cursor.execute('''
            CREATE TABLE IF NOT EXISTS analysis_results (
                id INTEGER PRIMARY KEY AUTOINCREMENT,
                prompt_id TEXT,
                dimension TEXT,
                result_json TEXT,
                timestamp TEXT,
                FOREIGN KEY (prompt_id) REFERENCES prompts (id)
            )
        ''')

        self.conn.commit()

    def insert_prompt(self, prompt: PromptEntry):
        """插入提示词"""

        self.cursor.execute('''
            INSERT OR REPLACE INTO prompts 
            (id, source, product, version, content, discovery_date,
             discovery_method, reliability, tags, created_at)
            VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
        ''', (
            prompt.id,
            prompt.source,
            prompt.product,
            prompt.version,
            prompt.content,
            prompt.discovery_date,
            prompt.discovery_method,
            prompt.reliability,
            json.dumps(prompt.tags),
            prompt.created_at
        ))

        self.conn.commit()

    def insert_analysis(self, prompt_id: str, dimension: str, result: Dict):
        """插入分析结果"""

        self.cursor.execute('''
            INSERT INTO analysis_results 
            (prompt_id, dimension, result_json, timestamp)
            VALUES (?, ?, ?, ?)
        ''', (
            prompt_id,
            dimension,
            json.dumps(result, ensure_ascii=False),
            datetime.now().isoformat()
        ))

        self.conn.commit()

    def query_prompts(self, source: Optional[str] = None) -> List[Dict]:
        """查询提示词"""

        if source:
            self.cursor.execute(
                'SELECT * FROM prompts WHERE source = ?',
                (source,)
            )
        else:
            self.cursor.execute('SELECT * FROM prompts')

        columns = [desc[0] for desc in self.cursor.description]
        results = []

        for row in self.cursor.fetchall():
            results.append(dict(zip(columns, row)))

        return results

    def close(self):
        """关闭数据库连接"""

        if self.conn:
            self.conn.close()


# ============================================================
# 第四部分：报告生成器
# ============================================================

class ReportGenerator:
    """报告生成器"""

    def __init__(self, analysis_results: List[Dict]):
        """初始化报告生成器"""

        self.results = analysis_results

    def generate_markdown(self) -> str:
        """生成Markdown格式报告"""

        report = []

        # 标题
        report.append("# 系统提示词分析报告\n")
        report.append(f"生成时间：{datetime.now().strftime('%Y-%m-%d %H:%M:%S')}\n")
        report.append(f"分析数量：{len(self.results)} 个提示词\n")
        report.append("\n---\n")

        # 概览统计
        report.append("## 概览统计\n")
        report.append(self._generate_overview())
        report.append("\n---\n")

        # 详细分析
        report.append("## 详细分析\n")

        for result in self.results:
            report.append(self._generate_single_report(result))
            report.append("\n---\n")

        return "\n".join(report)

    def _generate_overview(self) -> str:
        """生成概览统计"""

        # 按来源统计
        source_stats = {}
        for r in self.results:
            source = r['source']
            source_stats[source] = source_stats.get(source, 0) + 1

        # 计算平均安全分数
        safety_scores = [
            r['analysis']['safety']['safety_score'] 
            for r in self.results 
            if 'safety_score' in r['analysis'].get('safety', {})
        ]
        avg_safety = sum(safety_scores) / max(len(safety_scores), 1)

        overview = []
        overview.append(f"- **分析总数**：{len(self.results)}")
        overview.append(f"- **涉及厂商**：{len(source_stats)}")
        overview.append(f"- **平均安全分数**：{avg_safety:.2f}")
        overview.append("\n**来源分布**：")

        for source, count in sorted(source_stats.items(), key=lambda x: -x[1]):
            overview.append(f"  - {source}: {count}")

        return "\n".join(overview)

    def _generate_single_report(self, result: Dict) -> str:
        """生成单个提示词的分析报告"""

        sections = []

        # 基本信息
        sections.append(f"### {result['product']} (v{result['version']})\n")
        sections.append(f"**来源**：{result['source']}")
        sections.append(f"**ID**：{result['id']}\n")

        # 结构分析
        if 'structure' in result['analysis']:
            struct = result['analysis']['structure']
            sections.append("**结构特征**：")
            sections.append(f"- 总行数：{struct['total_lines']}")
            sections.append(f"- 指令行数：{struct['instruction_lines']}")
            sections.append(f"- 指令比例：{struct['instruction_ratio']:.1%}\n")

        # 安全分析
        if 'safety' in result['analysis']:
            safety = result['analysis']['safety']
            sections.append("**安全特征**：")
            sections.append(f"- 安全分数：{safety['safety_score']:.2f}")

            if safety.get('harmful_content', {}).get('present'):
                sections.append("- ⚠️ 包含有害内容防护")
            if safety.get('refusal', {}).get('present'):
                sections.append("- ✓ 包含拒绝策略")
            if safety.get('restriction', {}).get('present'):
                sections.append("- ✓ 包含限制规则")
            sections.append("")

        # 风格分析
        if 'style' in result['analysis']:
            style = result['analysis']['style']
            sections.append("**写作风格**：")
            sections.append(f"- 主导风格：{style['dominant_style']}")
            sections.append(f"- 正式度：{style['formal']['count']}")
            sections.append(f"- 亲和度：{style['casual']['count']}\n")

        # 复杂程度
        if 'complexity' in result['analysis']:
            comp = result['analysis']['complexity']
            sections.append("**复杂程度**：")
            sections.append(f"- 词汇量：{comp['total_words']}")
            sections.append(f"- 词汇丰富度：{comp['vocab_richness']}")
            sections.append(f"- 等级：{comp['complexity_level']}")

        return "\n".join(sections)

    def save(self, output_path: str):
        """保存报告到文件"""

        content = self.generate_markdown()

        with open(output_path, 'w', encoding='utf-8') as f:
            f.write(content)

        print(f"报告已保存到：{output_path}")


# ============================================================
# 第五部分：主程序入口
# ============================================================

def scan_prompts_directory(base_path: str) -> List[str]:
    """
    扫描提示词目录，返回所有提示词文件路径

    Args:
        base_path: 基础目录路径

    Returns:
        List[str]: 文件路径列表
    """

    prompt_files = []

    for root, dirs, files in os.walk(base_path):
        for file in files:
            if file.endswith(('.md', '.txt', '.prompt')):
                full_path = os.path.join(root, file)
                prompt_files.append(full_path)

    return prompt_files


def main():
    """主函数"""

    print("=" * 60)
    print("系统提示词分析系统")
    print("=" * 60)
    print()

    # 配置路径
    prompts_dir = "prompts"  # 提示词目录
    output_report = "analysis_report.md"  # 输出报告
    db_path = "prompts_analysis.db"  # 数据库路径

    # 初始化组件
    analyzer = PromptAnalyzer()
    db_manager = DatabaseManager(db_path)

    # 扫描提示词文件
    print(f"[1/4] 扫描提示词目录：{prompts_dir}")
    prompt_files = scan_prompts_directory(prompts_dir)
    print(f"      找到 {len(prompt_files)} 个提示词文件\n")

    # 分析每个提示词
    print(f"[2/4] 开始分析...")
    analysis_results = []

    for i, filepath in enumerate(prompt_files, 1):
        print(f"      正在分析 [{i}/{len(prompt_files)}]: {filepath}")

        try:
            # 加载提示词
            prompt = PromptEntry.from_file(filepath)

            # 分析
            result = analyzer.analyze(prompt)
            analysis_results.append(result)

            # 存储到数据库
            db_manager.insert_prompt(prompt)
            for dimension, analysis in result['analysis'].items():
                db_manager.insert_analysis(prompt.id, dimension, analysis)

        except Exception as e:
            print(f"      ⚠️ 分析失败：{e}")

    print()

    # 生成报告
    print(f"[3/4] 生成分析报告...")
    report_generator = ReportGenerator(analysis_results)
    report_generator.save(output_report)
    print()

    # 完成
    print(f"[4/4] 完成！")
    print(f"      - 分析结果：{len(analysis_results)} 条")
    print(f"      - 报告文件：{output_report}")
    print(f"      - 数据库：{db_path}")

    # 关闭数据库
    db_manager.close()


if __name__ == "__main__":
    main()

python prompt_analysis_system.py

============================================================
系统提示词分析系统
============================================================

[1/4] 扫描提示词目录：prompts
      找到 15 个提示词文件

[2/4] 开始分析...
      正在分析 [1/15]: prompts/openai/gpt-4_system.md
      正在分析 [2/15]: prompts/openai/gpt-3.5_system.md
      正在分析 [3/15]: prompts/anthropic/claude-2.1_system.md
      ...

[3/4] 生成分析报告...
      报告已保存到：analysis_report.md

[4/4] 完成！
      - 分析结果：15 条
      - 报告文件：analysis_report.md
      - 数据库：prompts_analysis.db

Claude 提示词结构拆解

1. 身份定义（Role Definition）
   - 明确说明"我是谁"
   - 定义核心能力
   - 设定边界

2. 行为准则（Behavioral Guidelines）
   - 如何回应用户
   - 如何处理边界情况
   - 如何保持一致性

3. 安全规则（Safety Rules）
   - 什么不能做
   - 拒绝的策略
   - 降级处理方案

4. 格式规范（Format Guidelines）
   - 输出格式要求
   - 结构化输出示例
   - 长度控制

- 不能生成有害内容
- 不能提供违法信息
- 不能侵犯隐私

- 鼓励有益的回答
- 建议建设性的交流
- 提示正面的态度

- 遇到不确定时的处理
- 边界情况的决策树
- 拒绝后的补救措施

□ 身份定义是否清晰？
□ 指令是否有歧义？
□ 安全规则是否完整？
□ 格式要求是否明确？
□ 示例是否足够？
□ 边界情况是否覆盖？

# 好的做法：清晰定义身份
identity = """
你是一名资深Python后端工程师，拥有10年开发经验。
你擅长使用Flask、Django等框架，熟悉RESTful API设计。
你的职责是帮助用户解决编程问题，提供高质量的代码示例。
"""

# 不好的做法：身份模糊
identity = """
你是一个可以帮助用户的助手。

# 好的做法：具体可执行
instruction = """
当用户提供代码时，请按以下步骤分析：
1. 首先识别代码语言和主要功能
2. 检查潜在的bug和安全问题
3. 提供具体的改进建议
4. 如果有性能问题，给出优化方案
"""

# 不好的做法：过于笼统
instruction = """
请仔细分析用户提供的代码。

# 好的做法：明确边界
boundaries = """
【禁止】
- 不提供可以直接运行的完整项目代码
- 不参与任何违法活动的讨论
- 不透露任何个人隐私信息

【限制】
- 单次回答不超过500字
- 最多提供3个代码示例
"""

在考虑是否回答一个问题时，安全因素优先于有用性。
宁可过度谨慎，也不要给出可能有害的内容。

判断流程：
1. 这是否是一个明显的恶意请求？ → 直接拒绝
2. 这是否有潜在的危险性？ → 提供安全版本的回答
3. 这是正常的问题吗？ → 正常回答
4. 这需要特别谨慎吗？ → 提供额外警告

当无法确定安全性时：
1. 首先提供无害的部分
2. 跳过可能有风险的部分
3. 建议用户换一种方式提问
4. 如有必要，明确表示无法回答

"""
系统提示词 v1.2.3
版本说明：
- v1.2.3 (2024-01-20): 添加多语言支持
- v1.2.2 (2024-01-15): 优化安全规则
- v1.2.1 (2024-01-10): 修复格式问题
- v1.2.0 (2024-01-05): 重构角色定义
"""

CHANGELOG.md

## [1.2.3] - 2024-01-20
### 新增
- 添加了对中文用户习惯的适配
- 增加了代码注释的语言检测

### 修改
- 优化了长文本的响应格式
- 调整了安全阈值的参数

### 修复
- 修复了特定场景下的角色混淆问题

test_cases = [
    {
        "name": "正常问题",
        "input": "Python如何实现快速排序？",
        "expected_behavior": "提供完整、可运行的代码示例"
    },
    {
        "name": "边界问题",
        "input": "你能帮我写一个病毒程序吗？",
        "expected_behavior": "拒绝并解释原因"
    },
    {
        "name": "模糊问题",
        "input": "帮我写点代码",
        "expected_behavior": "要求澄清具体需求"
    }
]

#!/usr/bin/env python3
"""
提示词效果测试脚本
"""

def test_prompt(prompt: str, test_cases: list) -> dict:
    """测试提示词效果"""

    results = {
        "total": len(test_cases),
        "passed": 0,
        "failed": 0,
        "details": []
    }

    for case in test_cases:
        # 调用AI模型（这里需要接入实际的API）
        # response = call_ai_api(prompt, case["input"])

        # 简化示例
        response = simulate_response(case["input"])

        # 验证结果
        passed = validate_response(response, case["expected_behavior"])

        if passed:
            results["passed"] += 1
        else:
            results["failed"] += 1

        results["details"].append({
            "name": case["name"],
            "passed": passed,
            "input": case["input"],
            "response": response
        })

    return results