@umituz/react-native-ai-generation-content 1.17.170 → 1.17.171

package/src/domains/prompts/infrastructure/services/TextGenerationService.ts

@@ -1,114 +1,41 @@
+/**
+ * Text Generation Service
+ * AI prompt generation for text content creation
+ */
+
 import type { ITextGenerationService } from '../../domain/repositories/IAIPromptServices';
-import type {
-  TextGenerationConfig,
-} from '../../domain/entities/TextGenerationConfig';
+import type { TextGenerationConfig } from '../../domain/entities/TextGenerationConfig';
 import type { AIPromptTemplate } from '../../domain/entities/AIPromptTemplate';
-import type { AIPromptResult } from '../../domain/entities/types';
-import { createAIPromptTemplate } from '../../domain/entities/AIPromptTemplate';
 import {
   validateTextGenerationConfig,
   getTokenCount,
   getTemperature,
-  getTopP
+  getTopP,
 } from '../../domain/entities/TextGenerationConfig';
-import { PromptGenerationService } from '../services/PromptGenerationService';
-
-const createTextGenerationBaseTemplate = (config?: {
-  promptType?: string;
-  tone?: string;
-  language?: string;
-}): string => {
-  const {
-    promptType = 'general',
-    tone = 'professional',
-    language = 'English'
-  } = config || {};
+import { BasePromptService } from './base';
 
-  return `
+const BASE_TEMPLATE = `
 You are an expert text generation specialist.
 This is a TEXT GENERATION task with specific requirements.
 
-GENERATION OBJECTIVES:
-- Generate ${promptType} content with ${tone} tone
-- Write in ${language} language
-- Follow provided context and constraints
-- Deliver high-quality, appropriate content
-
 CONTENT STANDARDS:
 - Clear, coherent, and well-structured text
 - Appropriate for the specified tone and purpose
 - Natural language flow and readability
-- Relevant and informative content
-
-STYLE REQUIREMENTS:
-- Maintain ${tone} tone throughout
-- Use appropriate vocabulary and expressions
-- Follow conventions for ${promptType} content
-- Adapt complexity to intended audience
-
-LANGUAGE REQUIREMENTS:
-- Write fluently in ${language}
-- Use proper grammar and syntax
-- Consider cultural and regional variations
-- Maintain consistency in language usage
 
-SAFETY AND QUALITY:
+SAFETY:
 - Generate appropriate, non-offensive content
 - Avoid harmful or misleading information
 - Ensure factual accuracy when applicable
 - Respect copyright and intellectual property
-
-OUTPUT:
-Professional ${promptType} content in ${language},
-written with ${tone} tone,
-meeting all specified requirements.
-  `.trim();
-};
-
-export class TextGenerationService implements ITextGenerationService {
-  private promptService: PromptGenerationService;
-
-  constructor() {
-    this.promptService = new PromptGenerationService();
-  }
-
-  generateTemplate(config: TextGenerationConfig): Promise<AIPromptResult<AIPromptTemplate>> {
-    try {
-      if (!this.validateConfig(config)) {
-        return Promise.resolve({
-          success: false,
-          error: 'VALIDATION_ERROR',
-          message: 'Invalid text generation configuration'
-        });
-      }
-
-      const template = this.createTextGenerationTemplate(config);
-      return Promise.resolve({ success: true, data: template });
-    } catch {
-      return Promise.resolve({
-        success: false,
-        error: 'GENERATION_FAILED',
-        message: 'Failed to generate text template'
-      });
-    }
-  }
-
-  async generatePrompt(
-    template: AIPromptTemplate,
-    config: TextGenerationConfig
-  ): Promise<AIPromptResult<string>> {
-    const parameters = this.getGenerationParameters(config);
-    const variables = {
-      promptType: config.promptType,
-      tone: config.tone,
-      length: config.length,
-      language: config.language,
-      context: config.context || '',
-      keywords: config.keywords?.join(', ') || '',
-      ...parameters,
-    };
-
-    return this.promptService.generateFromTemplate(template, variables);
+`.trim();
+
+export class TextGenerationService
+  extends BasePromptService<TextGenerationConfig>
+  implements ITextGenerationService
+{
+  protected getServiceName(): string {
+    return 'text generation';
   }
 
   validateConfig(config: TextGenerationConfig): boolean {
@@ -129,113 +56,35 @@ export class TextGenerationService implements ITextGenerationService {
     };
   }
 
-  private createTextGenerationTemplate(config: TextGenerationConfig): AIPromptTemplate {
-    const templateId = `text-generation-${config.promptType}`;
-
-    const baseTemplate = createTextGenerationBaseTemplate({
+  protected buildVariables(config: TextGenerationConfig): Record<string, unknown> {
+    return {
       promptType: config.promptType,
       tone: config.tone,
+      length: config.length,
       language: config.language,
-    });
+      context: config.context || '',
+      keywords: config.keywords?.join(', ') || '',
+      ...this.getGenerationParameters(config),
+    };
+  }
+
+  protected createTemplate(config: TextGenerationConfig): AIPromptTemplate {
+    const tokens = this.estimateTokens(config);
 
-    return createAIPromptTemplate({
-      id: templateId,
+    return this.createTemplateWithDefaults({
+      id: `text-generation-${config.promptType}`,
       name: `Text Generation: ${config.promptType}`,
       description: `Generate ${config.promptType} content in ${config.language}`,
       category: 'text-generation',
-      template: `${baseTemplate}
-
-GENERATION PARAMETERS:
-- Prompt Type: ${config.promptType}
-- Tone: ${config.tone}
-- Length: ${config.length}
-- Language: ${config.language}
-- Estimated Tokens: ${this.estimateTokens(config)}
-
-${config.context ? `CONTEXT:
-${config.context}
-
-` : ''}${config.keywords && config.keywords.length > 0 ? `KEYWORDS:
-${config.keywords.join(', ')}
-
-` : ''}CONTENT REQUIREMENTS:
-- Generate ${config.length} content appropriate for ${config.promptType}
-- Use ${config.tone} tone throughout the text
-- Follow conventions for ${config.promptType} writing
-- Write fluently in ${config.language}
-
-STYLE GUIDELINES:
-${this.getStyleGuidelines(config)}
-
-GENERATION PARAMETERS:
-- Temperature: ${getTemperature(config.promptType, config.tone)} (creativity level)
-- Max Tokens: ${this.estimateTokens(config)} (content length)
-- Top-P: ${getTopP(config.promptType)} (nucleus sampling)
-- Frequency Penalty: ${config.tone === 'formal' ? 0.3 : 0.1} (repetition reduction)
-- Presence Penalty: ${config.promptType === 'creative' ? 0.2 : 0.1} (new topic encouragement)
-
-EXPECTED OUTPUT:
-Professional ${config.promptType} content in ${config.language},
-approximately ${this.estimateTokens(config)} tokens long,
-with ${config.tone} tone and appropriate style.
-      `.trim(),
-      variables: [],
-      safety: {
-        contentFilter: true,
-        adultContentFilter: true,
-        violenceFilter: true,
-        hateSpeechFilter: true,
-        copyrightFilter: true,
-      },
-      version: '1.0.0',
+      template: `${BASE_TEMPLATE}
+
+TYPE: ${config.promptType}
+TONE: ${config.tone}
+LENGTH: ${config.length}
+LANGUAGE: ${config.language}
+TOKENS: ~${tokens}
+${config.context ? `CONTEXT: ${config.context}` : ''}
+${config.keywords?.length ? `KEYWORDS: ${config.keywords.join(', ')}` : ''}`,
     });
   }
-
-  private getStyleGuidelines(config: TextGenerationConfig): string {
-    const guidelines: string[] = [];
-
-    switch (config.promptType) {
-      case 'creative':
-        guidelines.push('- Use imaginative and engaging language');
-        guidelines.push('- Incorporate vivid descriptions and storytelling');
-        break;
-      case 'technical':
-        guidelines.push('- Use precise terminology and clear explanations');
-        guidelines.push('- Maintain logical structure and accuracy');
-        break;
-      case 'marketing':
-        guidelines.push('- Use persuasive and compelling language');
-        guidelines.push('- Include clear calls to action');
-        break;
-      case 'educational':
-        guidelines.push('- Present information clearly and progressively');
-        guidelines.push('- Include examples and explanations');
-        break;
-      case 'conversational':
-        guidelines.push('- Use natural, approachable language');
-        guidelines.push('- Include questions and engagement elements');
-        break;
-    }
-
-    switch (config.tone) {
-      case 'formal':
-        guidelines.push('- Maintain professional and respectful language');
-        guidelines.push('- Use proper grammar and complete sentences');
-        break;
-      case 'casual':
-        guidelines.push('- Use relaxed, natural language');
-        guidelines.push('- Include some conversational elements');
-        break;
-      case 'friendly':
-        guidelines.push('- Use warm and approachable tone');
-        guidelines.push('- Include encouraging and positive elements');
-        break;
-      case 'humorous':
-        guidelines.push('- Incorporate appropriate humor and wit');
-        guidelines.push('- Maintain lighthearted and engaging style');
-        break;
-    }
-
-    return guidelines.join('\n') || '- Follow standard writing conventions';
-  }
-}
+}

package/src/domains/prompts/infrastructure/services/base/index.ts

@@ -0,0 +1,6 @@
+/**
+ * Base Services Index
+ */
+
+export { BasePromptService, DEFAULT_PROMPT_SAFETY } from './prompt-service.base';
+export type { TemplateParams } from './prompt-service.base';

package/src/domains/prompts/infrastructure/services/base/prompt-service.base.ts

@@ -0,0 +1,112 @@
+/**
+ * Base Prompt Service
+ * Abstract class for AI prompt generation services
+ * Eliminates code duplication across service implementations
+ */
+
+import type { AIPromptTemplate } from '../../../domain/entities/AIPromptTemplate';
+import type { AIPromptResult, AIPromptCategory } from '../../../domain/entities/types';
+import type { AIPromptSafety } from '../../../domain/entities/value-objects';
+import { createAIPromptTemplate } from '../../../domain/entities/AIPromptTemplate';
+import { PromptGenerationService } from '../PromptGenerationService';
+
+/**
+ * Default safety configuration for all AI prompt templates
+ */
+export const DEFAULT_PROMPT_SAFETY: AIPromptSafety = {
+  contentFilter: true,
+  adultContentFilter: true,
+  violenceFilter: true,
+  hateSpeechFilter: true,
+  copyrightFilter: true,
+};
+
+/**
+ * Template creation parameters
+ */
+export interface TemplateParams {
+  id: string;
+  name: string;
+  description: string;
+  category: AIPromptCategory;
+  template: string;
+}
+
+/**
+ * Base class for AI prompt generation services
+ * Provides common functionality for template generation
+ */
+export abstract class BasePromptService<TConfig> {
+  protected readonly promptService: PromptGenerationService;
+
+  constructor() {
+    this.promptService = new PromptGenerationService();
+  }
+
+  /**
+   * Generate template with standard error handling
+   */
+  generateTemplate(config: TConfig): Promise<AIPromptResult<AIPromptTemplate>> {
+    try {
+      if (!this.validateConfig(config)) {
+        return Promise.resolve({
+          success: false,
+          error: 'VALIDATION_ERROR',
+          message: `Invalid ${this.getServiceName()} configuration`,
+        });
+      }
+
+      const template = this.createTemplate(config);
+      return Promise.resolve({ success: true, data: template });
+    } catch {
+      return Promise.resolve({
+        success: false,
+        error: 'GENERATION_FAILED',
+        message: `Failed to generate ${this.getServiceName()} template`,
+      });
+    }
+  }
+
+  /**
+   * Generate prompt from template
+   */
+  async generatePrompt(
+    template: AIPromptTemplate,
+    config: TConfig,
+  ): Promise<AIPromptResult<string>> {
+    const variables = this.buildVariables(config);
+    return this.promptService.generateFromTemplate(template, variables);
+  }
+
+  /**
+   * Create template with default safety config
+   */
+  protected createTemplateWithDefaults(params: TemplateParams): AIPromptTemplate {
+    return createAIPromptTemplate({
+      ...params,
+      variables: [],
+      safety: DEFAULT_PROMPT_SAFETY,
+      version: '1.0.0',
+    });
+  }
+
+  /**
+   * Service name for error messages
+   */
+  protected abstract getServiceName(): string;
+
+  /**
+   * Validate configuration
+   */
+  abstract validateConfig(config: TConfig): boolean;
+
+  /**
+   * Create the template (service-specific)
+   */
+  protected abstract createTemplate(config: TConfig): AIPromptTemplate;
+
+  /**
+   * Build variables for prompt generation
+   */
+  protected abstract buildVariables(config: TConfig): Record<string, unknown>;
+}