@umituz/react-native-ai-generation-content 1.17.31 → 1.17.34

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@umituz/react-native-ai-generation-content",
-  "version": "1.17.31",
+  "version": "1.17.34",
   "description": "Provider-agnostic AI generation orchestration for React Native",
   "main": "src/index.ts",
   "types": "src/index.ts",

package/src/domains/creations/presentation/components/FilterChips.tsx

@@ -58,7 +58,8 @@ export function FilterChips({
     [tokens],
   );
 
-  const visibleTypes = types.filter((t) => availableTypes.includes(t.id));
+  const safeAvailableTypes = availableTypes ?? [];
+  const visibleTypes = types.filter((t) => safeAvailableTypes.includes(t.id));
 
   return (
     <View style={[styles.container, style]}>

package/src/domains/flashcard-generation/FlashcardGenerationService.ts

@@ -0,0 +1,326 @@
+/**
+ * Flashcard Generation Service
+ * AI-powered flashcard generation for educational content
+ */
+
+import type {
+  GenerationRequest,
+  GenerationResult,
+  GenerationStatus,
+  PhotoGenerationInput,
+  DirectExecutionResult,
+} from "../domain/entities";
+
+export interface FlashcardGenerationRequest {
+  topic: string;
+  difficulty: "beginner" | "intermediate" | "advanced";
+  count: number;
+  language?: string;
+  format?: "qa" | "definition" | "fill_blank" | "multiple_choice";
+  context?: string;
+  tags?: string[];
+  includeImages?: boolean;
+}
+
+export interface GeneratedFlashcard {
+  id: string;
+  front: string;
+  back: string;
+  difficulty: "easy" | "medium" | "hard";
+  tags: string[];
+  source: "ai_generated";
+  generationRequest: FlashcardGenerationRequest;
+  confidence: number; // 0-1 score
+  createdAt?: string;
+}
+
+export interface FlashcardGenerationResult {
+  success: boolean;
+  flashcards: GeneratedFlashcard[];
+  creditsUsed: number;
+  tokensUsed: number;
+  processingTime: number; // milliseconds
+  error?: string;
+  requestId: string;
+}
+
+export class FlashcardGenerationService {
+  private static instance: FlashcardGenerationService;
+
+  static getInstance(): FlashcardGenerationService {
+    if (!FlashcardGenerationService.instance) {
+      FlashcardGenerationService.instance = new FlashcardGenerationService();
+    }
+    return FlashcardGenerationService.instance;
+  }
+
+  /**
+   * Generate flashcards using AI
+   */
+  async generateFlashcards(
+    request: FlashcardGenerationRequest,
+  ): Promise<FlashcardGenerationResult> {
+    try {
+      const startTime = Date.now();
+
+      // Create AI generation prompt
+      const prompt = this.buildFlashcardPrompt(request);
+
+      // Use the AI generation orchestrator
+      const generationRequest: GenerationRequest = {
+        prompt,
+        type: "text_to_text" as any,
+        options: {
+          maxTokens: this.calculateMaxTokens(request.count),
+          temperature: 0.7,
+          language: request.language || "en",
+        },
+      };
+
+      const result = await this.executeGeneration(generationRequest);
+
+      // Parse AI response into flashcards
+      const flashcards = this.parseFlashcardsFromResult(result, request);
+      const processingTime = Date.now() - startTime;
+
+      return {
+        success: true,
+        flashcards,
+        creditsUsed: request.count * 2, // 2 credits per flashcard
+        tokensUsed: result.metadata?.tokensUsed || 0,
+        processingTime,
+        requestId: result.jobId || `req_${Date.now()}`,
+      };
+    } catch (error) {
+      return {
+        success: false,
+        flashcards: [],
+        creditsUsed: 0,
+        tokensUsed: 0,
+        processingTime: 0,
+        error: error instanceof Error ? error.message : "Unknown error",
+        requestId: "",
+      };
+    }
+  }
+
+  /**
+   * Validate generated flashcard content
+   */
+  async validateFlashcard(
+    front: string,
+    back: string,
+  ): Promise<{
+    accuracy: number;
+    relevance: number;
+    clarity: number;
+    completeness: number;
+    overall: number;
+  }> {
+    // Simple validation heuristic
+    const frontLength = front.length;
+    const backLength = back.length;
+
+    const accuracy = this.calculateAccuracy(front, back);
+    const relevance = this.calculateRelevance(front, back);
+    const clarity = this.calculateClarity(front, back);
+    const completeness = this.calculateCompleteness(front, back);
+    const overall = (accuracy + relevance + clarity + completeness) / 4;
+
+    return {
+      accuracy,
+      relevance,
+      clarity,
+      completeness,
+      overall,
+    };
+  }
+
+  private buildFlashcardPrompt(request: FlashcardGenerationRequest): string {
+    const qualityMap = {
+      beginner:
+        "simple, clear language appropriate for learners just starting out",
+      intermediate:
+        "moderate complexity with some technical terms expected to be known",
+      advanced:
+        "complex content with specialized terminology and nuanced concepts",
+    };
+
+    const formatInstructions = {
+      qa: "Format as Question-Answer pairs",
+      definition: "Format as Term-Definition pairs",
+      fill_blank: "Format as Fill-in-the-blank exercises",
+      multiple_choice:
+        "Format as Multiple Choice questions with one correct answer",
+    };
+
+    return `Generate ${request.count} educational flashcards about "${request.topic}".
+    
+Topic Context: ${request.context || "General learning"}
+Difficulty Level: ${request.difficulty} - ${qualityMap[request.difficulty]}
+Format: ${request.format || "qa"} - ${formatInstructions[request.format || "qa"]}
+Language: ${request.language || "English"}
+Tags to include: ${request.tags?.join(", ") || "auto-generated"}
+
+Requirements:
+- Questions should be clear and concise
+- Answers should be accurate and comprehensive
+- Content should be age and difficulty appropriate
+- Include relevant educational context
+- Make it engaging and memorable
+
+Output format: JSON array with structure:
+[
+  {
+    "front": "Question text here",
+    "back": "Answer text here",
+    "difficulty": "easy|medium|hard",
+    "tags": ["tag1", "tag2"]
+  }
+]`;
+  }
+
+  private calculateMaxTokens(count: number): number {
+    // Estimate ~50 tokens per flashcard + overhead
+    return Math.max(count * 50, 200);
+  }
+
+  private async executeGeneration(request: GenerationRequest): Promise<any> {
+    // This would integrate with the actual AI generation orchestrator
+    // For now, return mock result
+    await new Promise((resolve) => setTimeout(resolve, 2000));
+
+    return {
+      success: true,
+      result: this.generateMockContent(request.options?.maxTokens || 200),
+      metadata: {
+        tokensUsed: request.options?.maxTokens || 200,
+        processingTime: 2000,
+      },
+      jobId: `job_${Date.now()}`,
+    };
+  }
+
+  private generateMockContent(maxTokens: number): string {
+    const mockFlashcards = [
+      {
+        front: "What is photosynthesis?",
+        back: "The process by which plants convert sunlight, water, and carbon dioxide into glucose and oxygen.",
+        difficulty: "medium",
+        tags: ["biology", "science", "plants"],
+      },
+      {
+        front: "Define gravity",
+        back: "A fundamental force that attracts objects with mass toward each other.",
+        difficulty: "easy",
+        tags: ["physics", "science", "forces"],
+      },
+      {
+        front: "What is the formula for water?",
+        back: "H₂O",
+        difficulty: "easy",
+        tags: ["chemistry", "science", "molecules"],
+      },
+    ];
+
+    return JSON.stringify(mockFlashcards.slice(0, Math.floor(maxTokens / 100)));
+  }
+
+  private parseFlashcardsFromResult(
+    result: any,
+    request: FlashcardGenerationRequest,
+  ): GeneratedFlashcard[] {
+    try {
+      let flashcards: any[];
+
+      if (typeof result.result === "string") {
+        flashcards = JSON.parse(result.result);
+      } else if (Array.isArray(result.result)) {
+        flashcards = result.result;
+      } else {
+        throw new Error("Invalid AI response format");
+      }
+
+      return flashcards.map((item, index) => ({
+        id: `generated_${Date.now()}_${index}`,
+        front: item.front || "",
+        back: item.back || "",
+        difficulty: item.difficulty || "medium",
+        tags: Array.isArray(item.tags)
+          ? item.tags
+          : item.tags
+            ? [item.tags]
+            : [],
+        source: "ai_generated" as const,
+        generationRequest: request,
+        confidence: 0.8 + Math.random() * 0.2, // 0.8-1.0
+        createdAt: new Date().toISOString(),
+      }));
+    } catch (error) {
+      console.error("Failed to parse AI response:", error);
+      return [];
+    }
+  }
+
+  private calculateAccuracy(front: string, back: string): number {
+    // Simple heuristics for accuracy assessment
+    let score = 0.5; // Base score
+
+    // Check for reasonable length
+    if (front.length >= 5 && front.length <= 200) score += 0.2;
+    if (back.length >= 10 && back.length <= 500) score += 0.2;
+
+    // Check for balanced content
+    const frontWords = front.split(/\s+/).length;
+    const backWords = back.split(/\s+/).length;
+    if (backWords >= frontWords * 0.5 && backWords <= frontWords * 3)
+      score += 0.1;
+
+    return Math.min(score, 1.0);
+  }
+
+  private calculateRelevance(front: string, back: string): number {
+    // Simple relevance check
+    let score = 0.6; // Base score
+
+    // Check for educational content indicators
+    const educationalTerms = [
+      "define",
+      "explain",
+      "describe",
+      "what is",
+      "how does",
+      "formula",
+      "process",
+      "function",
+    ];
+    const hasEducationalTerms = educationalTerms.some(
+      (term) =>
+        front.toLowerCase().includes(term) || back.toLowerCase().includes(term),
+    );
+
+    if (hasEducationalTerms) score += 0.3;
+    if (front.includes("?") || front.toLowerCase().includes("what is"))
+      score += 0.1;
+
+    return Math.min(score, 1.0);
+  }
+
+  private calculateClarity(front: string, back: string): number {
+    let score = 0.5; // Base score
+
+    // Check for clear structure
+    if (front.trim().endsWith("?")) score += 0.2;
+    if (!front.includes("...") && !back.includes("...")) score += 0.2;
+    if (!/[A-Z]{2,}/.test(front)) score += 0.1; // Not too many caps
+
+    return Math.min(score, 1.0);
+  }
+
+  private calculateCompleteness(front: string, back: string): number {
+    const frontScore = Math.min(front.length / 20, 1.0); // Ideal 20 chars
+    const backScore = Math.min(back.length / 50, 1.0); // Ideal 50 chars
+
+    return (frontScore + backScore) / 2;
+  }
+}

package/src/presentation/hooks/useFlashcardGeneration.ts

@@ -0,0 +1,154 @@
+/**
+ * Flashcard Generation Hooks
+ * React hooks for AI-powered flashcard generation
+ */
+
+import React from "react";
+import type {
+  FlashcardGenerationRequest,
+  GeneratedFlashcard,
+  FlashcardGenerationResult,
+} from "../domains/flashcard-generation/FlashcardGenerationService";
+
+export interface UseFlashcardGenerationResult {
+  generateFlashcards: (
+    request: FlashcardGenerationRequest,
+  ) => Promise<FlashcardGenerationResult>;
+  isGenerating: boolean;
+  result: FlashcardGenerationResult | null;
+  error: string | null;
+}
+
+export const useFlashcardGeneration = (): UseFlashcardGenerationResult => {
+  const [isGenerating, setIsGenerating] = React.useState(false);
+  const [result, setResult] = React.useState<FlashcardGenerationResult | null>(
+    null,
+  );
+  const [error, setError] = React.useState<string | null>(null);
+
+  const generateFlashcards = React.useCallback(
+    async (
+      request: FlashcardGenerationRequest,
+    ): Promise<FlashcardGenerationResult> => {
+      try {
+        setIsGenerating(true);
+        setError(null);
+
+        // This would use the actual FlashcardGenerationService
+        // For now, mock the implementation
+        await new Promise((resolve) => setTimeout(resolve, 2000));
+
+        const flashcards: GeneratedFlashcard[] = [];
+        for (let i = 0; i < request.count; i++) {
+          flashcards.push({
+            id: `generated_${Date.now()}_${i}`,
+            front: `Mock question ${i + 1} about ${request.topic}`,
+            back: `Mock answer ${i + 1} for ${request.topic}`,
+            difficulty: i % 3 === 0 ? "easy" : i % 3 === 1 ? "medium" : "hard",
+            tags: [
+              ...(request.tags || []),
+              request.topic.toLowerCase().replace(/\s+/g, "_"),
+            ],
+            source: "ai_generated",
+            generationRequest: request,
+            confidence: 0.8 + Math.random() * 0.2,
+            createdAt: new Date().toISOString(),
+          });
+        }
+
+        const generationResult: FlashcardGenerationResult = {
+          success: true,
+          flashcards,
+          creditsUsed: request.count * 2,
+          tokensUsed: request.count * 100,
+          processingTime: 2000,
+          requestId: `req_${Date.now()}`,
+        };
+
+        setResult(generationResult);
+        return generationResult;
+      } catch (err) {
+        const errorMessage =
+          err instanceof Error ? err.message : "Generation failed";
+        setError(errorMessage);
+        setIsGenerating(false);
+
+        return {
+          success: false,
+          flashcards: [],
+          creditsUsed: 0,
+          tokensUsed: 0,
+          processingTime: 0,
+          error: errorMessage,
+          requestId: `req_${Date.now()}`,
+        };
+      } finally {
+        setIsGenerating(false);
+      }
+    },
+    [],
+  );
+
+  const reset = React.useCallback(() => {
+    setResult(null);
+    setError(null);
+    setIsGenerating(false);
+  }, []);
+
+  return {
+    generateFlashcards,
+    isGenerating,
+    result,
+    error,
+    reset,
+  };
+};
+
+export interface UseFlashcardValidationResult {
+  validateFlashcard: (
+    front: string,
+    back: string,
+  ) => Promise<{
+    accuracy: number;
+    relevance: number;
+    clarity: number;
+    completeness: number;
+    overall: number;
+  }>;
+  isValidating: boolean;
+}
+
+export const useFlashcardValidation = (): UseFlashcardValidationResult => {
+  const [isValidating, setIsValidating] = React.useState(false);
+
+  const validateFlashcard = React.useCallback(
+    async (front: string, back: string) => {
+      setIsValidating(true);
+
+      // Mock validation - in production would use actual service
+      await new Promise((resolve) => setTimeout(resolve, 500));
+
+      const accuracy = Math.min(1, front.length / 10);
+      const relevance = Math.min(1, back.length / 25);
+      const clarity = Math.min(1, 1 - front.split(/\s+/).length / 20);
+      const completeness = Math.min(1, back.length / 50);
+      const overall = (accuracy + relevance + clarity + completeness) / 4;
+
+      setIsValidating(false);
+
+      return {
+        accuracy,
+        relevance,
+        clarity,
+        completeness,
+        overall,
+      };
+    },
+    [],
+  );
+
+  return {
+    validateFlashcard,
+    isValidating,
+  };
+};