Prompt模板管理模块

你是一位专业的{{locale_name}}新闻编辑。
请根据以下素材，撰写一篇{{word_count}}字左右的新闻摘要。
要求语气{{tone}}，目标读者是{{audience}}。
 
## 素材
{{raw_content}}
 
## 输出格式
请按以下 JSON 格式输出：
{"title": "...", "summary": "...", "tags": ["..."]}

# 角色
你是一位资深的{{locale_name}}科技记者，擅长将复杂的技术概念转化为大众能理解的语言。
 
# 任务
根据提供的产品信息，撰写一段面向普通消费者的功能介绍。
 
# 约束
- 不超过 {{word_count}} 字
- 不使用技术术语，必须使用时需附简短解释
- 禁止使用「颠覆性」「革命性」等夸大词汇
 
# 产品信息
{{product_info}}

// Prompt 模板主表
interface PromptTemplate {
  id: string
  name: string
  scene: 'content_generation' | 'conversation' | 'translation' | 'classification' | 'code_gen'
  status: 'draft' | 'testing' | 'ready' | 'canary' | 'live' | 'deprecated'
  owner_id: string
  locale: string           // 出海产品需要区分语言版本
  current_version_id: string
  created_at: Date
  updated_at: Date
}
 
// 版本表
interface PromptVersion {
  id: string
  template_id: string
  version_number: string   // 如 "3.2"
  content: string          // Prompt 模板内容（含 Jinja2 变量）
  model_config: {
    model: string          // 如 "gpt-4o"
    temperature: number
    max_tokens: number
    top_p: number
  }
  change_note: string      // 版本变更说明
  status: 'draft' | 'testing' | 'approved' | 'rejected'
  test_results?: TestResult[]
  created_by: string
  created_at: Date
}
 
// A/B 测试实验表
interface PromptExperiment {
  id: string
  name: string
  template_id: string
  variants: {
    version_id: string
    weight: number         // 流量权重，如 50 表示 50%
  }[]
  split_strategy: 'user_hash' | 'round_robin' | 'geo'
  metrics: {
    primary: string        // 主要评估指标
    secondary: string[]    // 辅助指标
  }
  min_sample_size: number
  status: 'running' | 'completed' | 'cancelled'
  started_at: Date
  ended_at?: Date
}

import { Template } from 'jinja2-esm'  // 或其他 Jinja2 实现
 
class PromptRenderer {
  // 渲染模板：将变量注入模板，返回最终 Prompt 文本
  render(version: PromptVersion, variables: Record<string, string>): string {
    const template = new Template(version.content)
    const rendered = template.render(variables)
 
    // 安全检查：确保所有变量都被替换
    const missingVars = rendered.match(/\{\{.*?\}\}/g)
    if (missingVars) {
      throw new Error(
        `模板渲染不完整，未替换变量: ${missingVars.join(', ')}`
      )
    }
 
    return rendered
  }
 
  // 获取当前生效版本的 Prompt，支持 A/B 测试分流
  async resolve(templateId: string, userId: string): Promise<PromptVersion> {
    // 1. 检查是否有正在运行的 A/B 测试
    const experiment = await this.getActiveExperiment(templateId)
 
    if (experiment) {
      // 2. 根据分流策略选择版本
      const variantIndex = this.splitVariant(experiment, userId)
      const variant = experiment.variants[variantIndex]
      return this.getVersion(variant.version_id)
    }
 
    // 3. 无实验时返回当前生效版本
    const template = await this.getTemplate(templateId)
    return this.getVersion(template.current_version_id)
  }
 
  // 基于用户 ID 哈希的确定性分流
  private splitVariant(experiment: PromptExperiment, userId: string): number {
    const hash = this.simpleHash(`${experiment.id}:${userId}`)
    const normalized = hash % 100
    let cumulative = 0
    for (let i = 0; i < experiment.variants.length; i++) {
      cumulative += experiment.variants[i].weight
      if (normalized < cumulative) return i
    }
    return experiment.variants.length - 1
  }
 
  private simpleHash(str: string): number {
    let hash = 0
    for (let i = 0; i < str.length; i++) {
      hash = ((hash << 5) - hash) + str.charCodeAt(i)
      hash |= 0
    }
    return Math.abs(hash)
  }
}

// 创建新版本
async function createVersion(
  templateId: string,
  content: string,
  modelConfig: PromptVersion['model_config'],
  changeNote: string,
  operatorId: string
): Promise<PromptVersion> {
  const versions = await db.promptVersions.findMany({
    where: { template_id: templateId },
    orderBy: { created_at: 'desc' }
  })
 
  // 自动生成版本号
  const lastVersion = versions[0]
  const newVersionNumber = incrementVersion(lastVersion?.version_number ?? '0.0')
 
  const version = await db.promptVersions.create({
    data: {
      id: generateId(),
      template_id: templateId,
      version_number: newVersionNumber,
      content,
      model_config: modelConfig,
      change_note: changeNote,
      status: 'draft',
      created_by: operatorId,
      created_at: new Date()
    }
  })
 
  // 记录审计日志
  await db.auditLogs.create({
    data: {
      action: 'prompt_version_created',
      entity_id: version.id,
      entity_type: 'prompt_version',
      operator_id: operatorId,
      metadata: { template_id: templateId, version_number: newVersionNumber }
    }
  })
 
  return version
}
 
// 回滚到指定版本
async function rollbackVersion(
  templateId: string,
  targetVersionId: string,
  reason: string,
  operatorId: string
): Promise<void> {
  const targetVersion = await db.promptVersions.findUnique({
    where: { id: targetVersionId }
  })
 
  if (!targetVersion || targetVersion.template_id !== templateId) {
    throw new Error('目标版本不存在或不属于该模板')
  }
 
  await db.promptTemplates.update({
    where: { id: templateId },
    data: {
      current_version_id: targetVersionId,
      updated_at: new Date()
    }
  })
 
  await db.auditLogs.create({
    data: {
      action: 'prompt_version_rollback',
      entity_id: templateId,
      entity_type: 'prompt_template',
      operator_id: operatorId,
      metadata: {
        target_version_id: targetVersionId,
        target_version_number: targetVersion.version_number,
        reason
      }
    }
  })
}

import { diffLines } from 'diff'
 
function computeDiff(oldContent: string, newContent: string) {
  const changes = diffLines(oldContent, newContent)
  return changes.map(change => ({
    type: change.added ? 'added' : change.removed ? 'removed' : 'unchanged',
    value: change.value
  }))
}
 
// 返回值示例：
// [
//   { type: 'unchanged', value: '你是一位专业的新闻编辑。\n' },
//   { type: 'removed',   value: '请撰写一篇摘要。\n' },
//   { type: 'added',     value: '请撰写一篇300字左右的新闻摘要。\n' },
//   { type: 'unchanged', value: '要求语气客观...' }
// ]