Initial commit

skills/prompt/tests/integration.test.ts

@@ -0,0 +1,233 @@
+import { describe, it, expect, beforeEach } from 'bun:test';
+import { AdvancedPromptCrafter } from '../src/index.js';
+import type { PromptRequest } from '../src/types.js';
+
+describe('AdvancedPromptCrafter Integration', () => {
+  let crafter: AdvancedPromptCrafter;
+
+  beforeEach(() => {
+    crafter = new AdvancedPromptCrafter();
+  });
+
+  describe('analyzeAndOptimize', () => {
+    it('should analyze and optimize a simple prompt', async () => {
+      const prompt = 'Write a blog post about AI';
+      const result = await crafter.analyzeAndOptimize(prompt, {
+        mode: 'creative',
+        targetModel: 'claude-3-sonnet',
+        outputFormat: 'markdown',
+      });
+
+      expect(result).toBeDefined();
+      expect(result.originalPrompt).toBe(prompt);
+      expect(result.optimizedPrompt).toBeDefined();
+      expect(result.analysis).toBeDefined();
+      expect(result.optimization).toBeDefined();
+      expect(result.validation).toBeDefined();
+      expect(result.responseTime).toBeGreaterThan(0);
+      expect(result.metadata.mode).toBe('creative');
+      expect(result.metadata.model).toBe('claude-3-sonnet');
+    });
+
+    it('should handle technical mode correctly', async () => {
+      const prompt = 'Create a REST API';
+      const result = await crafter.analyzeAndOptimize(prompt, {
+        mode: 'technical',
+        domain: 'technical',
+      });
+
+      expect(result.optimizedPrompt).toContain('Technical');
+      expect(result.metadata.mode).toBe('technical');
+      expect(result.metadata.domain).toBe('technical');
+    });
+
+    it('should handle complex prompts correctly', async () => {
+      const prompt =
+        'Design a comprehensive microservices architecture with API gateway, service discovery, load balancing, and monitoring';
+      const result = await crafter.analyzeAndOptimize(prompt, {
+        mode: 'technical',
+        targetModel: 'claude-3-opus',
+      });
+
+      expect(result.analysis.complexity).toBe('high');
+      expect(result.optimization.techniques).toContain('tot');
+      expect(result.optimizedPrompt.length).toBeGreaterThan(prompt.length);
+    });
+  });
+
+  describe('createPrompt', () => {
+    it('should create a prompt from requirements', async () => {
+      const request: PromptRequest = {
+        task: 'Generate TypeScript code for a REST API',
+        domain: 'technical',
+        mode: 'technical',
+        requirements: {
+          include: ['types', 'validation', 'error-handling'],
+          exclude: ['external-apis'],
+        },
+        context: 'E-commerce platform backend',
+      };
+
+      const result = await crafter.createPrompt(request);
+
+      expect(result).toBeDefined();
+      expect(result.optimizedPrompt).toContain('TypeScript');
+      expect(result.optimizedPrompt).toContain('REST API');
+      expect(result.optimizedPrompt).toContain('validation');
+      expect(result.optimizedPrompt).toContain('error-handling');
+      expect(result.optimizedPrompt).toContain('E-commerce');
+    });
+
+    it('should create prompts for different domains', async () => {
+      const requests = [
+        {
+          task: 'Write a business plan',
+          domain: 'business',
+          mode: 'business' as const,
+        },
+        {
+          task: 'Create a story',
+          domain: 'creative',
+          mode: 'creative' as const,
+        },
+        {
+          task: 'Conduct research analysis',
+          domain: 'research',
+          mode: 'research' as const,
+        },
+      ];
+
+      for (const request of requests) {
+        const result = await crafter.createPrompt(request);
+        expect(result.metadata.domain).toBe(request.domain);
+        expect(result.metadata.mode).toBe(request.mode);
+      }
+    });
+  });
+
+  describe('getQualityMetrics', () => {
+    it('should return quality metrics for a prompt', async () => {
+      const prompt =
+        'Write a comprehensive technical guide about React hooks with practical examples.';
+      const metrics = await crafter.getQualityMetrics(prompt);
+
+      expect(metrics).toBeDefined();
+      expect(metrics.clarity).toBeGreaterThan(0);
+      expect(metrics.specificity).toBeGreaterThan(0);
+      expect(metrics.completeness).toBeGreaterThan(0);
+      expect(metrics.efficiency).toBeGreaterThan(0);
+      expect(metrics.consistency).toBeGreaterThan(0);
+      expect(metrics.errorRate).toBeGreaterThanOrEqual(0);
+      expect(metrics.overall).toBeGreaterThan(0);
+    });
+  });
+
+  describe('createABTestVariations', () => {
+    it('should create A/B test variations', async () => {
+      const prompt = 'Create a blog post about technology';
+      const variations = await crafter.createABTestVariations(prompt, 3);
+
+      expect(variations).toHaveLength(3);
+      expect(variations.every(v => v.originalPrompt === prompt)).toBe(true);
+      expect(variations.every(v => v.optimizedPrompt !== prompt)).toBe(true);
+      expect(variations.every(v => v.analysis)).toBeDefined();
+      expect(variations.every(v => v.validation)).toBeDefined();
+    });
+
+    it('should create different variations', async () => {
+      const prompt = 'Write about AI';
+      const variations = await crafter.createABTestVariations(prompt, 3);
+
+      const optimizedPrompts = variations.map(v => v.optimizedPrompt);
+      const uniquePrompts = new Set(optimizedPrompts);
+
+      expect(uniquePrompts.size).toBe(3);
+    });
+  });
+
+  describe('performance', () => {
+    it('should complete analysis within reasonable time', async () => {
+      const prompt = 'Write a technical blog post about web development';
+      const startTime = Date.now();
+
+      const result = await crafter.analyzeAndOptimize(prompt);
+
+      const endTime = Date.now();
+      const duration = endTime - startTime;
+
+      expect(duration).toBeLessThan(5000); // Should complete within 5 seconds
+      expect(result.responseTime).toBe(duration);
+    });
+
+    it('should handle concurrent requests', async () => {
+      const prompts = Array(5)
+        .fill(null)
+        .map((_, i) => `Test prompt ${i + 1}`);
+
+      const startTime = Date.now();
+      const results = await Promise.all(prompts.map(prompt => crafter.analyzeAndOptimize(prompt)));
+      const endTime = Date.now();
+
+      expect(results).toHaveLength(5);
+      expect(endTime - startTime).toBeLessThan(10000); // Should complete within 10 seconds
+    });
+  });
+
+  describe('error handling', () => {
+    it('should handle empty prompts gracefully', async () => {
+      const result = await crafter.analyzeAndOptimize('');
+
+      expect(result).toBeDefined();
+      expect(result.validation.qualityScore).toBeLessThan(5);
+      expect(result.validation.approved).toBe(false);
+      expect(result.validation.issues.length).toBeGreaterThan(0);
+    });
+
+    it('should handle very long prompts', async () => {
+      const longPrompt = `${'Write '.repeat(1000)  }about technology`;
+      const result = await crafter.analyzeAndOptimize(longPrompt);
+
+      expect(result).toBeDefined();
+      expect(result.optimizedPrompt).toBeDefined();
+    });
+
+    it('should handle special characters', async () => {
+      const specialPrompt = 'Write about AI & ML, including "Python", <code>, and {examples}!';
+      const result = await crafter.analyzeAndOptimize(specialPrompt);
+
+      expect(result).toBeDefined();
+      expect(result.optimizedPrompt).toBeDefined();
+    });
+  });
+
+  describe('configuration', () => {
+    it('should accept custom configuration', async () => {
+      const customCrafter = new AdvancedPromptCrafter({
+        analysis: {
+          nlpProvider: 'custom',
+          analysisDepth: 'deep',
+          userProfile: {
+            expertise: 'expert',
+            preferences: ['detailed', 'comprehensive'],
+          },
+        },
+        optimization: {
+          techniques: ['cot', 'react'],
+          enableABTesting: false,
+          performanceThreshold: 0.9,
+        },
+        validation: {
+          qualityThreshold: 9.0,
+          enableBenchmarking: false,
+          metrics: ['clarity', 'specificity'],
+        },
+      });
+
+      const result = await customCrafter.analyzeAndOptimize('Test prompt');
+
+      expect(result).toBeDefined();
+      expect(result.optimization.techniques).toContain('cot');
+      expect(result.optimization.techniques).toContain('react');
+    });
+  });
+});