const fs = require('fs');
const path = require('path');
class ScenarioPromptGenerator {
constructor() {
this.scenarios = {
code_generation: {
name: '代码生成场景',
contexts: {
api_development: {
name: 'API开发',
roleTemplate: '你是一名资深的{tech_stack}后端开发工程师，拥有{experience}年企业级应用开发经验。',
taskTemplate: '请为我开发{functionality}，具体要求如下：',
requirements: [
'功能需求',
'技术要求',
'代码质量要求',
'输出格式'
],
qualityChecks: [
'代码可直接运行',
'包含错误处理',
'遵循最佳实践',
'有完整注释'
]
},
frontend_component: {
name: '前端组件开发',
roleTemplate: '你是一名资深的{framework}前端架构师，专注于企业级组件库开发。',
taskTemplate: '请帮我开发一个高质量的{component_type}组件，要求如下：',
requirements: [
'组件功能',
'技术栈',
'设计原则',
'交付内容'
],
qualityChecks: [
'TypeScript类型完整',
'性能优化到位',
'可访问性支持',
'测试覆盖完整'
]
}
}
},
content_creation: {
name: '内容创作场景',
contexts: {
technical_blog: {
name: '技术博客',
roleTemplate: '你是一名资深的技术博主和开发者布道师，擅长将复杂的技术概念转化为易懂的内容。',
taskTemplate: '请为我创作一篇关于"{topic}"的技术博客文章，目标读者是{target_audience}。',
requirements: [
'文章要求',
'内容框架',
'写作要求',
'SEO优化'
],
qualityChecks: [
'内容准确专业',
'结构清晰完整',
'代码示例可运行',
'实用价值高'
]
},
marketing_copy: {
name: '营销文案',
roleTemplate: '你是一名资深的数字营销专家和文案策划师，专注于{industry}产品的营销推广。',
taskTemplate: '请为我们的{product_name}产品创作一套营销文案，目标用户是{target_users}。',
requirements: [
'产品信息',
'目标用户画像',
'文案套装要求',
'文案风格'
],
qualityChecks: [
'价值主张清晰',
'用户痛点准确',
'情感共鸣强烈',
'转化导向明确'
]
}
}
},
data_analysis: {
name: '数据分析场景',
contexts: {
business_analysis: {
name: '业务数据分析',
roleTemplate: '你是一名资深的数据分析师，专注于{industry}行业，有丰富的{analysis_type}分析经验。',
taskTemplate: '请帮我分析以下{business_type}的数据，并提供优化建议：',
requirements: [
'数据背景',
'关键数据',
'分析要求',
'输出要求'
],
qualityChecks: [
'分析逻辑清晰',
'洞察深入准确',
'建议可操作',
'风险评估完整'
]
}
}
},
problem_solving: {
name: '问题解决场景',
contexts: {
technical_diagnosis: {
name: '技术故障诊断',
roleTemplate: '你是一名资深的{expertise}专家，有{experience}年大规模系统的设计和运维经验。',
taskTemplate: '我们的{system_type}系统出现了{problem_type}问题，请帮我进行系统性的诊断和优化。',
requirements: [
'系统概况',
'问题现象',
'监控数据',
'诊断流程'
],
qualityChecks: [
'问题定位准确',
'解决方案可行',
'实施计划详细',
'预防措施完善'
]
}
}
}
};
}
generateScenarioPrompt(scenarioType, contextType, parameters = {}) {
const scenario = this.scenarios[scenarioType];
const context = scenario?.contexts[contextType];
if (!scenario || !context) {
throw new Error(`场景或上下文不存在: ${scenarioType}.${contextType}`);
}
console.log(`\n🎯 生成${scenario.name} - ${context.name}提示`);
console.log('=' .repeat(50));
let rolePrompt = context.roleTemplate;
Object.keys(parameters).forEach(key => {
rolePrompt = rolePrompt.replace(`{${key}}`, parameters[key]);
});
let taskPrompt = context.taskTemplate;
Object.keys(parameters).forEach(key => {
taskPrompt = taskPrompt.replace(`{${key}}`, parameters[key]);
});
const requirementSections = context.requirements.map(req => {
const paramKey = req.toLowerCase().replace(/\s+/g, '_');
const content = parameters[paramKey] || `[请填写${req}]`;
return `【${req}】\n${content}`;
}).join('\n\n');
const qualityChecks = context.qualityChecks.map((check, index) =>
`${index + 1}. ${check}`
).join('\n');
const fullPrompt = `${rolePrompt}
${taskPrompt}
${requirementSections}
【质量标准】
${qualityChecks}
请确保输出满足所有质量标准，并提供完整、可执行的解决方案。`;
console.log('📝 生成的场景化Prompt:');
console.log(fullPrompt);
return {
scenarioType,
contextType,
prompt: fullPrompt,
parameters,
metadata: {
scenarioName: scenario.name,
contextName: context.name,
generatedAt: new Date().toISOString()
}
};
}
listAvailableScenarios() {
console.log('\n📋 可用的场景和上下文:');
Object.entries(this.scenarios).forEach(([scenarioKey, scenario]) => {
console.log(`\n${scenario.name} (${scenarioKey}):`);
Object.entries(scenario.contexts).forEach(([contextKey, context]) => {
console.log(` - ${context.name} (${contextKey})`);
});
});
}
generateParameterTemplate(scenarioType, contextType) {
const scenario = this.scenarios[scenarioType];
const context = scenario?.contexts[contextType];
if (!scenario || !context) {
throw new Error(`场景或上下文不存在: ${scenarioType}.${contextType}`);
}
console.log(`\n📋 ${context.name}参数模板`);
console.log('=' .repeat(30));
const roleParams = this.extractParameters(context.roleTemplate);
const taskParams = this.extractParameters(context.taskTemplate);
const allParams = [...new Set([...roleParams, ...taskParams])];
const template = {
scenario: scenarioType,
context: contextType,
parameters: {}
};
allParams.forEach(param => {
template.parameters[param] = `[请填写${param}]`;
});
context.requirements.forEach(req => {
const paramKey = req.toLowerCase().replace(/\s+/g, '_');
template.parameters[paramKey] = `[请填写${req}]`;
});
console.log('📄 参数模板:');
console.log(JSON.stringify(template, null, 2));
return template;
}
extractParameters(template) {
const matches = template.match(/{([^}]+)}/g);
return matches ? matches.map(match => match.slice(1, -1)) : [];
}
batchGenerate(scenarios) {
console.log(`\n🔄 批量生成${scenarios.length}个场景提示`);
const results = scenarios.map((scenario, index) => {
console.log(`\n处理第${index + 1}个场景...`);
try {
const result = this.generateScenarioPrompt(
scenario.scenarioType,
scenario.contextType,
scenario.parameters
);
return {
success: true,
...result
};
} catch (error) {
console.error(`生成失败: ${error.message}`);
return {
success: false,
error: error.message,
...scenario
};
}
});
const outputPath = './scenario_prompts_batch.json';
fs.writeFileSync(outputPath, JSON.stringify(results, null, 2));
console.log(`\n💾 批量结果已保存到: ${outputPath}`);
return results;
}
saveScenarioLibrary(scenarios, libraryName = 'custom_scenarios') {
const library = {
name: libraryName,
createdAt: new Date().toISOString(),
scenarios: scenarios,
metadata: {
totalScenarios: scenarios.length,
successCount: scenarios.filter(s => s.success).length,
failureCount: scenarios.filter(s => !s.success).length
}
};
const libraryPath = path.join('./prompt_libraries', `${libraryName}.json`);
const dir = path.dirname(libraryPath);
if (!fs.existsSync(dir)) {
fs.mkdirSync(dir, { recursive: true });
}
fs.writeFileSync(libraryPath, JSON.stringify(library, null, 2));
console.log(`\n📚 场景库已保存到: ${libraryPath}`);
return library;
}
}
class PromptQualityAssessor {
constructor() {
this.qualityMetrics = {
clarity: {
name: '清晰度',
weight: 0.25,
criteria: [
{ pattern: /请|帮我|需要/, score: 10, desc: '明确的请求表达' },
{ pattern: /具体|详细|明确/, score: 15, desc: '具体化描述' },
{ pattern: /\d+字|\d+个|\d+条/, score: 10, desc: '量化要求' },
{ pattern: /格式|结构|组织/, score: 10, desc: '格式要求' }
]
},
completeness: {
name: '完整性',
weight: 0.25,
criteria: [
{ pattern: /你是|作为/, score: 15, desc: '角色设定' },
{ pattern: /背景|场景|情况/, score: 10, desc: '背景信息' },
{ pattern: /要求|标准|规范/, score: 15, desc: '质量标准' },
{ pattern: /示例|例如|比如/, score: 10, desc: '示例说明' }
]
},
specificity: {
name: '具体性',
weight: 0.25,
criteria: [
{ pattern: /[A-Za-z]+\.[A-Za-z]+|Node\.js|React|Python/, score: 15, desc: '技术栈明确' },
{ pattern: /\d+年|\d+个月|\d+天/, score: 10, desc: '时间具体' },
{ pattern: /企业级|生产环境|商业/, score: 10, desc: '应用场景具体' },
{ pattern: /性能|安全|可维护/, score: 10, desc: '质量属性具体' }
]
},
actionability: {
name: '可操作性',
weight: 0.25,
criteria: [
{ pattern: /步骤|流程|方法/, score: 15, desc: '步骤化指导' },
{ pattern: /输出|交付|提供/, score: 10, desc: '明确输出要求' },
{ pattern: /测试|验证|检查/, score: 10, desc: '验证方法' },
{ pattern: /实施|执行|部署/, score: 10, desc: '实施指导' }
]
}
};
}
assessPromptQuality(prompt, expectedOutputType = 'general') {
console.log('\n🔍 Prompt质量评估');
console.log('=' .repeat(30));
console.log(`提示长度: ${prompt.length} 字符`);
console.log(`预期输出类型: ${expectedOutputType}\n`);
const assessment = {
overall: 0,
metrics: {},
suggestions: [],
strengths: [],
weaknesses: []
};
let totalWeightedScore = 0;
let maxWeightedScore = 0;
for (const [metricKey, metric] of Object.entries(this.qualityMetrics)) {
const metricResult = this.evaluateMetric(prompt, metric);
assessment.metrics[metricKey] = metricResult;
const weightedScore = metricResult.score * metric.weight;
const maxWeighted = metricResult.maxScore * metric.weight;
totalWeightedScore += weightedScore;
maxWeightedScore += maxWeighted;
console.log(`${metric.name}: ${metricResult.score}/${metricResult.maxScore} (${metricResult.percentage}%)`);
if (metricResult.percentage >= 80) {
assessment.strengths.push(`${metric.name}表现优秀`);
} else if (metricResult.percentage < 50) {
assessment.weaknesses.push(`${metric.name}需要改进`);
}
}
assessment.overall = Math.round((totalWeightedScore / maxWeightedScore) * 100);
console.log(`\n🎯 总体评分: ${assessment.overall}/100`);
assessment.suggestions = this.generateImprovementSuggestions(assessment.metrics, expectedOutputType);
if (assessment.suggestions.length > 0) {
console.log('\n💡 改进建议:');
assessment.suggestions.forEach((suggestion, index) => {
console.log(`${index + 1}. ${suggestion}`);
});
}
if (assessment.strengths.length > 0) {
console.log('\n✅ 优势:');
assessment.strengths.forEach(strength => console.log(`- ${strength}`));
}
if (assessment.weaknesses.length > 0) {
console.log('\n⚠️ 需要改进:');
assessment.weaknesses.forEach(weakness => console.log(`- ${weakness}`));
}
return assessment;
}
evaluateMetric(prompt, metric) {
let score = 0;
let maxScore = 0;
const matchedCriteria = [];
for (const criterion of metric.criteria) {
maxScore += criterion.score;
if (criterion.pattern.test(prompt)) {
score += criterion.score;
matchedCriteria.push(criterion.desc);
}
}
return {
score,
maxScore,
percentage: Math.round((score / maxScore) * 100),
matchedCriteria
};
}
generateImprovementSuggestions(metrics, outputType) {
const suggestions = [];
if (metrics.clarity.percentage < 60) {
suggestions.push('添加更明确的任务描述和具体要求');
suggestions.push('使用量化指标明确输出标准');
}
if (metrics.completeness.percentage < 60) {
suggestions.push('添加角色设定以激活相关知识');
suggestions.push('提供更多背景信息和上下文');
}
if (metrics.specificity.percentage < 60) {
suggestions.push('明确技术栈和工具选择');
suggestions.push('添加具体的应用场景和约束条件');
}
if (metrics.actionability.percentage < 60) {
suggestions.push('添加步骤化的执行指导');
suggestions.push('明确输出格式和验证标准');
}
const typeSpecificSuggestions = this.getTypeSpecificSuggestions(outputType, metrics);
suggestions.push(...typeSpecificSuggestions);
return [...new Set(suggestions)];
}
getTypeSpecificSuggestions(outputType, metrics) {
const suggestions = [];
switch (outputType) {
case 'code':
if (metrics.specificity.percentage < 70) {
suggestions.push('明确编程语言、框架和版本要求');
suggestions.push('添加代码风格和质量标准');
}
break;
case 'analysis':
if (metrics.actionability.percentage < 70) {
suggestions.push('明确分析框架和方法论');
suggestions.push('要求提供可操作的建议和行动计划');
}
break;
case 'content':
if (metrics.clarity.percentage < 70) {
suggestions.push('明确目标受众和内容风格');
suggestions.push('添加字数、结构等格式要求');
}
break;
}
return suggestions;
}
comparePrompts(prompts, labels = []) {
console.log(`\n📊 对比${prompts.length}个Prompt的质量`);
console.log('=' .repeat(50));
const comparisons = prompts.map((prompt, index) => {
const label = labels[index] || `Prompt ${index + 1}`;
console.log(`\n评估 ${label}:`);
return {
label,
assessment: this.assessPromptQuality(prompt)
};
});
console.log('\n📈 对比总结:');
comparisons.forEach(comp => {
console.log(`${comp.label}: ${comp.assessment.overall}/100`);
});
const best = comparisons.reduce((prev, current) =>
current.assessment.overall > prev.assessment.overall ? current : prev
);
console.log(`\n🏆 最佳Prompt: ${best.label} (${best.assessment.overall}/100)`);
return comparisons;
}
generateQualityReport(assessment, promptText) {
const report = {
timestamp: new Date().toISOString(),
prompt: {
text: promptText,
length: promptText.length,
wordCount: promptText.split(/\s+/).length
},
assessment,
recommendations: {
immediate: assessment.suggestions.slice(0, 3),
longTerm: assessment.suggestions.slice(3),
priority: this.prioritizeRecommendations(assessment)
}
};
const reportPath = './prompt_quality_report.json';
fs.writeFileSync(reportPath, JSON.stringify(report, null, 2));
console.log(`\n📄 质量报告已保存到: ${reportPath}`);
return report;
}
prioritizeRecommendations(assessment) {
const priorities = [];
Object.entries(assessment.metrics).forEach(([key, metric]) => {
if (metric.percentage < 50) {
priorities.push({ dimension: key, priority: 'high', score: metric.percentage });
} else if (metric.percentage < 70) {
priorities.push({ dimension: key, priority: 'medium', score: metric.percentage });
}
});
return priorities.sort((a, b) => a.score - b.score);
}
}
const scenarioGenerator = new ScenarioPromptGenerator();
const qualityAssessor = new PromptQualityAssessor();
console.log('🚀 Prompt实战工具集演示\n');
scenarioGenerator.listAvailableScenarios();
const apiPrompt = scenarioGenerator.generateScenarioPrompt('code_generation', 'api_development', {
tech_stack: 'Node.js',
experience: '5',
functionality: '用户管理系统API',
功能需求: '用户注册、登录、信息管理、权限控制',
技术要求: 'Express + TypeScript + MongoDB + JWT',
代码质量要求: 'RESTful设计、完整错误处理、安全防护',
输出格式: '项目结构 + 核心代码 + 使用文档'
});
const assessment = qualityAssessor.assessPromptQuality(apiPrompt.prompt, 'code');
const report = qualityAssessor.generateQualityReport(assessment, apiPrompt.prompt);
module.exports = { ScenarioPromptGenerator, PromptQualityAssessor };