Prompt Engineering Mastery: Advanced Techniques for AI Applications

// Zero-shot prompt examples
const prompts = {
  // Basic instruction
  classification: `Classify the sentiment of this text: "I love this product!"
  
  Sentiment:`,

  // Clear task definition
  translation: `Translate the following English text to French:
  "Hello, how are you today?"
  
  French translation:`,

  // Structured output request
  extraction: `Extract the key information from this text:
  "John Smith, age 30, works as a software engineer at TechCorp"
  
  Format as JSON with fields: name, age, profession, company`,
};

class FewShotPromptBuilder {
  static buildClassificationPrompt(examples: Example[], newText: string): string {
    const examplePrompts = examples.map(ex => 
      `Text: "${ex.text}"\nSentiment: ${ex.sentiment}`
    ).join('\n\n');

    return `Here are some examples of sentiment classification:

${examplePrompts}

Now classify this text:
Text: "${newText}"
Sentiment:`;
  }

  static buildExtractionPrompt(examples: ExtractionExample[], newText: string): string {
    const examplePrompts = examples.map(ex => 
      `Input: ${ex.input}\nOutput: ${JSON.stringify(ex.output)}`
    ).join('\n\n');

    return `Extract structured information from text. Here are examples:

${examplePrompts}

Extract information from:
Input: ${newText}
Output:`;
  }

  // Dynamic few-shot selection
  static selectBestExamples(
    allExamples: Example[], 
    query: string, 
    maxExamples = 3
  ): Example[] {
    // Calculate similarity and select most relevant examples
    const scored = allExamples.map(example => ({
      example,
      similarity: this.calculateSimilarity(query, example.text)
    }));

    return scored
      .sort((a, b) => b.similarity - a.similarity)
      .slice(0, maxExamples)
      .map(item => item.example);
  }

  private static calculateSimilarity(text1: string, text2: string): number {
    // Simple similarity calculation - in production, use embeddings
    const words1 = new Set(text1.toLowerCase().split(/\s+/));
    const words2 = new Set(text2.toLowerCase().split(/\s+/));
    
    const intersection = new Set([...words1].filter(x => words2.has(x)));
    const union = new Set([...words1, ...words2]);
    
    return intersection.size / union.size; // Jaccard similarity
  }
}

class ChainOfThoughtPrompts {
  // Mathematical reasoning
  static mathProblem(problem: string): string {
    return `Solve this step by step:

Problem: ${problem}

Let me think through this step by step:
1. First, I need to identify what the problem is asking for
2. Then, I'll break down the problem into smaller parts
3. I'll solve each part systematically
4. Finally, I'll combine the results for the final answer

Step 1:`;
  }

  // Logical reasoning
  static logicalReasoning(scenario: string): string {
    return `Analyze this scenario step by step:

Scenario: ${scenario}

Let me work through this logically:
1. What are the key facts?
2. What are the assumptions?
3. What logical rules apply?
4. What can we conclude?

Analysis:`;
  }

  // Code debugging
  static codeDebugging(code: string, error: string): string {
    return `Debug this code step by step:

Code:
${code}

Error: ${error}

Let me debug this systematically:
1. First, I'll understand what the code is supposed to do
2. Then, I'll analyze the error message
3. I'll trace through the code execution
4. I'll identify the root cause
5. Finally, I'll provide a fix

Step 1 - Understanding the code:`;
  }

  // Decision making
  static decisionAnalysis(situation: string, options: string[]): string {
    const optionsList = options.map((opt, i) => `${i + 1}. ${opt}`).join('\n');
    
    return `Analyze this decision systematically:

Situation: ${situation}

Options:
${optionsList}

Let me evaluate each option step by step:
1. First, I'll identify the key criteria for evaluation
2. Then, I'll assess each option against these criteria
3. I'll consider potential risks and benefits
4. Finally, I'll make a reasoned recommendation

Step 1 - Key criteria:`;
  }
}

class RoleBasedPrompts {
  static expertConsultant(domain: string, query: string): string {
    return `You are a world-class expert in ${domain} with 20+ years of experience. 
You have helped Fortune 500 companies solve complex problems in this field.

A client asks: "${query}"

Provide a comprehensive, expert-level response that includes:
1. Your analysis of the situation
2. Best practices and industry standards
3. Specific recommendations
4. Potential risks and mitigation strategies
5. Implementation timeline

Response:`;
  }

  static technicalReviewer(code: string, technology: string): string {
    return `You are a senior ${technology} architect conducting a code review. 
You have extensive experience building scalable, maintainable systems.

Review this code:
${code}

Provide feedback on:
1. Code quality and best practices
2. Performance considerations
3. Security implications
4. Maintainability and readability
5. Specific improvement suggestions

Code Review:`;
  }

  static creativeWriter(style: string, topic: string): string {
    return `You are an award-winning ${style} writer known for your engaging, 
compelling storytelling and deep understanding of human psychology.

Write about: ${topic}

Your writing should:
1. Capture the reader's attention immediately
2. Use vivid, sensory language
3. Create emotional connection
4. Tell a compelling story
5. Leave a lasting impression

Story:`;
  }

  static dataAnalyst(data: string, question: string): string {
    return `You are a senior data analyst with expertise in statistical analysis, 
machine learning, and business intelligence. You excel at finding insights in data.

Data: ${data}

Question: ${question}

Analyze the data and provide:
1. Key findings and patterns
2. Statistical significance
3. Business implications
4. Recommendations for action
5. Confidence levels and limitations

Analysis:`;
  }
}

class PromptTemplates {
  // STAR method for behavioral questions
  static starTemplate(situation: string): string {
    return `Using the STAR method, describe:

Situation: ${situation}

Please structure your response as:
- Situation: What was the context?
- Task: What needed to be accomplished?
- Action: What specific actions did you take?
- Result: What was the outcome?

Response:`;
  }

  // Problem-solving framework
  static problemSolvingTemplate(problem: string): string {
    return `Solve this problem using a structured approach:

Problem: ${problem}

Use this framework:
1. DEFINE: What exactly is the problem?
2. ANALYZE: What are the root causes?
3. GENERATE: What are possible solutions?
4. EVALUATE: What are the pros/cons of each solution?
5. IMPLEMENT: What's the recommended action plan?
6. MONITOR: How will we measure success?

Solution:`;
  }

  // Business case template
  static businessCaseTemplate(proposal: string): string {
    return `Create a business case for: ${proposal}

Structure your response as follows:

EXECUTIVE SUMMARY
- Brief overview and recommendation

PROBLEM STATEMENT
- Current state and challenges

PROPOSED SOLUTION
- Detailed description of the proposal

BENEFITS
- Quantified business value

COSTS
- Implementation and operational costs

RISK ANALYSIS
- Potential risks and mitigation strategies

RECOMMENDATION
- Clear go/no-go recommendation

Business Case:`;
  }

  // Research synthesis template
  static researchSynthesis(topic: string, sources: string[]): string {
    const sourceList = sources.map((s, i) => `${i + 1}. ${s}`).join('\n');
    
    return `Synthesize research on: ${topic}

Sources:
${sourceList}

Provide a comprehensive synthesis including:

OVERVIEW
- Current state of knowledge

KEY FINDINGS
- Major insights and discoveries

CONSENSUS & DISAGREEMENT
- Areas of agreement and debate

IMPLICATIONS
- Practical applications

FUTURE RESEARCH
- Gaps and opportunities

Research Synthesis:`;
  }
}

class PromptABTester {
  private experiments: Map<string, Experiment> = new Map();
  private results: Map<string, ExperimentResult[]> = new Map();

  async runExperiment(
    experimentId: string,
    prompts: string[],
    testData: TestCase[],
    evaluationCriteria: EvaluationCriteria
  ): Promise<ExperimentResult> {
    const experiment: Experiment = {
      id: experimentId,
      prompts,
      testData,
      criteria: evaluationCriteria,
      startTime: new Date(),
    };

    this.experiments.set(experimentId, experiment);

    const results: ExperimentResult[] = [];

    for (let i = 0; i < prompts.length; i++) {
      const promptResults = await this.testPrompt(
        prompts[i],
        testData,
        evaluationCriteria,
        `variant_${i}`
      );
      results.push(promptResults);
    }

    this.results.set(experimentId, results);

    return this.analyzeResults(results);
  }

  private async testPrompt(
    prompt: string,
    testData: TestCase[],
    criteria: EvaluationCriteria,
    variantName: string
  ): Promise<ExperimentResult> {
    const responses: PromptResponse[] = [];

    for (const testCase of testData) {
      const fullPrompt = this.buildPrompt(prompt, testCase.input);
      const response = await this.callLLM(fullPrompt);
      
      const evaluation = await this.evaluateResponse(
        response,
        testCase.expectedOutput,
        criteria
      );

      responses.push({
        input: testCase.input,
        output: response,
        evaluation,
        latency: evaluation.latency,
      });
    }

    return {
      variantName,
      prompt,
      responses,
      metrics: this.calculateMetrics(responses),
    };
  }

  private async evaluateResponse(
    response: string,
    expected: string,
    criteria: EvaluationCriteria
  ): Promise<Evaluation> {
    const startTime = Date.now();

    // Multiple evaluation methods
    const scores = {
      accuracy: await this.calculateAccuracy(response, expected),
      relevance: await this.calculateRelevance(response, expected),
      coherence: await this.calculateCoherence(response),
      completeness: await this.calculateCompleteness(response, expected),
    };

    return {
      scores,
      overallScore: this.calculateOverallScore(scores, criteria.weights),
      latency: Date.now() - startTime,
    };
  }

  private calculateMetrics(responses: PromptResponse[]): Metrics {
    const scores = responses.map(r => r.evaluation.overallScore);
    const latencies = responses.map(r => r.latency);

    return {
      avgScore: scores.reduce((a, b) => a + b, 0) / scores.length,
      scoreStdDev: this.calculateStdDev(scores),
      avgLatency: latencies.reduce((a, b) => a + b, 0) / latencies.length,
      successRate: scores.filter(s => s > 0.7).length / scores.length,
      p95Latency: this.calculatePercentile(latencies, 95),
    };
  }

  async getWinningPrompt(experimentId: string): Promise<string> {
    const results = this.results.get(experimentId);
    if (!results) throw new Error('Experiment not found');

    // Statistical significance testing
    const winner = results.reduce((best, current) => 
      current.metrics.avgScore > best.metrics.avgScore ? current : best
    );

    // Verify statistical significance
    const isSignificant = await this.checkStatisticalSignificance(
      results,
      winner
    );

    if (!isSignificant) {
      throw new Error('No statistically significant winner found');
    }

    return winner.prompt;
  }
}

class PromptManager {
  private prompts: Map<string, PromptVersion[]> = new Map();
  private activeVersions: Map<string, string> = new Map();
  private fallbackPrompts: Map<string, string> = new Map();

  registerPrompt(
    name: string,
    template: string,
    metadata: PromptMetadata
  ): string {
    const version = this.generateVersion();
    const promptVersion: PromptVersion = {
      version,
      template,
      metadata,
      createdAt: new Date(),
      isActive: false,
      performance: null,
    };

    if (!this.prompts.has(name)) {
      this.prompts.set(name, []);
    }

    this.prompts.get(name)!.push(promptVersion);
    return version;
  }

  async deployPrompt(
    name: string,
    version: string,
    rolloutStrategy: RolloutStrategy = { type: 'immediate' }
  ): Promise<void> {
    const prompt = this.getPromptVersion(name, version);
    if (!prompt) throw new Error('Prompt version not found');

    switch (rolloutStrategy.type) {
      case 'immediate':
        this.activeVersions.set(name, version);
        break;
      case 'canary':
        await this.deployCanary(name, version, rolloutStrategy.percentage);
        break;
      case 'gradual':
        await this.deployGradual(name, version, rolloutStrategy.stages);
        break;
    }

    // Update active status
    this.updateActiveStatus(name, version);
  }

  async getPrompt(
    name: string,
    context?: PromptContext
  ): Promise<string> {
    try {
      const activeVersion = this.activeVersions.get(name);
      if (!activeVersion) {
        throw new Error(`No active version for prompt: ${name}`);
      }

      const prompt = this.getPromptVersion(name, activeVersion);
      if (!prompt) {
        throw new Error(`Active version not found: ${activeVersion}`);
      }

      // Apply context and personalization
      return this.renderPrompt(prompt.template, context);

    } catch (error) {
      // Fallback to safe default
      const fallback = this.fallbackPrompts.get(name);
      if (fallback) {
        console.warn(`Using fallback prompt for ${name}:`, error);
        return fallback;
      }
      throw error;
    }
  }

  private renderPrompt(template: string, context?: PromptContext): string {
    if (!context) return template;

    // Template variable replacement
    let rendered = template;
    for (const [key, value] of Object.entries(context.variables || {})) {
      rendered = rendered.replace(
        new RegExp(`\\{\\{\\s*${key}\\s*\\}\\}`, 'g'),
        String(value)
      );
    }

    // Apply personalization
    if (context.user) {
      rendered = this.personalizePrompt(rendered, context.user);
    }

    // Apply conditional logic
    if (context.conditions) {
      rendered = this.applyConditions(rendered, context.conditions);
    }

    return rendered;
  }

  async recordPerformance(
    name: string,
    version: string,
    metrics: PerformanceMetrics
  ): Promise<void> {
    const prompt = this.getPromptVersion(name, version);
    if (!prompt) return;

    if (!prompt.performance) {
      prompt.performance = {
        totalCalls: 0,
        avgScore: 0,
        avgLatency: 0,
        errorRate: 0,
        lastUpdated: new Date(),
      };
    }

    // Update running averages
    const perf = prompt.performance;
    const newTotal = perf.totalCalls + 1;
    
    perf.avgScore = (perf.avgScore * perf.totalCalls + metrics.score) / newTotal;
    perf.avgLatency = (perf.avgLatency * perf.totalCalls + metrics.latency) / newTotal;
    perf.errorRate = (perf.errorRate * perf.totalCalls + (metrics.error ? 1 : 0)) / newTotal;
    perf.totalCalls = newTotal;
    perf.lastUpdated = new Date();
  }

  getPerformanceReport(name: string): PerformanceReport {
    const versions = this.prompts.get(name) || [];
    const activeVersion = this.activeVersions.get(name);

    return {
      promptName: name,
      activeVersion,
      versions: versions.map(v => ({
        version: v.version,
        isActive: v.version === activeVersion,
        performance: v.performance,
        metadata: v.metadata,
      })),
      recommendations: this.generateRecommendations(versions),
    };
  }
}

class CodeGenerationPrompts {
  static functionGeneration(description: string, language: string): string {
    return `Generate a ${language} function based on this description:

Description: ${description}

Requirements:
1. Follow ${language} best practices and conventions
2. Include proper error handling
3. Add comprehensive documentation/comments
4. Include type hints/annotations where applicable
5. Write clean, readable, maintainable code

Generated code:`;
  }

  static codeReview(code: string, language: string): string {
    return `Perform a comprehensive code review for this ${language} code:

```${language}
${code}
```

Review checklist:
✓ Functionality: Does the code work as intended?
✓ Readability: Is the code clear and well-structured?
✓ Performance: Are there any performance issues?
✓ Security: Are there any security vulnerabilities?
✓ Best practices: Does it follow language conventions?
✓ Error handling: Is error handling appropriate?
✓ Testing: Is the code testable?

Provide specific feedback with examples and suggestions for improvement.

Code Review:`;
  }

  static algorithmOptimization(algorithm: string, constraints: string): string {
    return `Optimize this algorithm for better performance:

Current algorithm:
${algorithm}

Constraints: ${constraints}

Analysis approach:
1. Analyze current time/space complexity
2. Identify bottlenecks and inefficiencies
3. Propose optimizations
4. Compare complexity before/after
5. Consider trade-offs

Provide optimized solution with complexity analysis.

Optimization:`;
  }

  static debuggingAssistant(code: string, error: string, language: string): string {
    return `Help debug this ${language} code:

Code:
```${language}
${code}
```

Error: ${error}

Debugging process:
1. Understand the intended behavior
2. Analyze the error message
3. Trace code execution path
4. Identify root cause
5. Provide fix with explanation
6. Suggest prevention strategies

Debug analysis:`;
  }
}

class ContentCreationPrompts {
  static blogPostGeneration(topic: string, audience: string, tone: string): string {
    return `Write a comprehensive blog post:

Topic: ${topic}
Target audience: ${audience}
Tone: ${tone}

Structure your post with:
1. Compelling headline
2. Engaging introduction with hook
3. Well-organized main content with subheadings
4. Practical examples and actionable insights
5. Strong conclusion with call-to-action

Requirements:
- 1500-2000 words
- SEO-optimized with relevant keywords
- Include practical tips and examples
- Engaging and valuable to the reader

Blog post:`;
  }

  static productDescription(product: string, features: string[], audience: string): string {
    const featureList = features.map(f => `- ${f}`).join('\n');
    
    return `Create a compelling product description:

Product: ${product}
Key features:
${featureList}
Target audience: ${audience}

Write a description that:
1. Captures attention with a strong opening
2. Highlights key benefits (not just features)
3. Addresses customer pain points
4. Creates emotional connection
5. Includes social proof elements
6. Ends with clear call-to-action

Focus on benefits over features and speak directly to customer needs.

Product description:`;
  }

  static emailCampaign(
    purpose: string, 
    audience: string, 
    offer: string
  ): string {
    return `Create an email campaign:

Purpose: ${purpose}
Audience: ${audience}
Offer: ${offer}

Campaign elements needed:
1. Subject line (compelling, not spammy)
2. Preheader text
3. Email body with clear structure
4. Strong call-to-action
5. Personalization elements

Email should:
- Build trust and credibility
- Create urgency without being pushy
- Provide clear value proposition
- Be mobile-friendly
- Include social proof

Email campaign:`;
  }

  static socialMediaStrategy(
    brand: string, 
    platforms: string[], 
    goals: string[]
  ): string {
    const platformList = platforms.join(', ');
    const goalList = goals.map(g => `- ${g}`).join('\n');
    
    return `Develop a social media strategy:

Brand: ${brand}
Platforms: ${platformList}
Goals:
${goalList}

Create a comprehensive strategy including:
1. Content pillars and themes
2. Posting frequency and timing
3. Content types for each platform
4. Engagement tactics
5. Hashtag strategy
6. Metrics to track
7. Sample content calendar (1 week)

Strategy should be specific, actionable, and aligned with goals.

Social media strategy:`;
  }
}