myavana-bot-test-core 2.3.4 → 2.4.0

package/index.js

@@ -38,6 +38,7 @@ const modules = {
     getConversationHistory: safeRequire('./src/conversation', 'conversation')?.getConversationHistory,
     saveConversation: safeRequire('./src/conversation', 'conversation')?.saveConversation,
     generateConversationSummary: safeRequire('./src/conversation', 'conversation')?.generateConversationSummary,
+    getUserConversationsList: safeRequire('./src/conversation', 'conversation')?.getUserConversationsList,
   
     // Post-processing and hair issues
     postProcessConversation: safeRequire('./src/postResponseProcessing', 'postResponseProcessing')?.postProcessConversation,
@@ -55,6 +56,7 @@ const modules = {
     getAdditionalInstructions: safeRequire('./src/utils', 'utils')?.getAdditionalInstructions,
     getTrainingData: safeRequire('./src/utils', 'utils')?.getTrainingData,
     getChatbotWelcomeSettings: safeRequire('./src/utils', 'utils')?.getChatbotWelcomeSettings,
+    buildBudgetedPromptContext: safeRequire('./src/context/promptBudgetManager', 'promptBudgetManager')?.buildBudgetedPromptContext,
 };
 
 // Smart systems - Load with proper error handling and fallbacks
@@ -170,6 +172,19 @@ const enhancedModules = {
     HealthMonitor: safeRequire('./src/healthMonitor', 'HealthMonitor')
 };
 
+// Hair Journey Platform Services
+const hairJourneyModules = {
+    HairJourneyService: safeRequire('./src/hairJourney/hairJourneyService', 'hairJourneyService')?.HairJourneyService,
+    WordPressHairJourneyProvider: safeRequire('./src/hairJourney/wordPressHairJourneyProvider', 'wordPressHairJourneyProvider')?.WordPressHairJourneyProvider,
+    ExperienceContextService: safeRequire('./src/experience/experienceContextService', 'experienceContextService')?.ExperienceContextService,
+};
+
+// Chat Protocol (NDJSON streaming, semantic blocks, response parsing)
+const chatProtocolModules = {
+    chatProtocol: safeRequire('./src/chatProtocol', 'chatProtocol'),
+    ...(safeRequire('./src/chatProtocol', 'chatProtocol') || {}),
+};
+
 // Export all modules
 module.exports = {
     ...modules,
@@ -181,6 +196,8 @@ module.exports = {
     ...agentToolModules,
     ...funnelEventModules,
     ...agentMemoryModules,
+    ...hairJourneyModules,
+    ...chatProtocolModules,
 };
 
 // Log export summary

package/migrations/001_add_analytics_tables.sql

@@ -68,6 +68,7 @@ CREATE INDEX IF NOT EXISTS idx_user_journey_events_user ON user_journey_events(u
 CREATE INDEX IF NOT EXISTS idx_ai_model_performance_date ON ai_model_performance(date_tracked);
 
 -- Views for easy analytics queries
+DROP VIEW IF EXISTS daily_conversation_stats CASCADE;
 CREATE OR REPLACE VIEW daily_conversation_stats AS
 SELECT 
     DATE(created_at) as date,
@@ -79,14 +80,15 @@ FROM conversation_metrics
 GROUP BY DATE(created_at)
 ORDER BY date DESC;
 
+DROP VIEW IF EXISTS model_reliability_stats CASCADE;
 CREATE OR REPLACE VIEW model_reliability_stats AS
 SELECT 
     model_name,
     SUM(request_count) as total_requests,
     SUM(success_count) as total_successes,
     SUM(failure_count) as total_failures,
-    ROUND((SUM(success_count)::float / SUM(request_count)::float * 100), 2) as success_rate,
-    ROUND(AVG(avg_response_time_ms), 2) as avg_response_time
+    ROUND((SUM(success_count)::numeric / NULLIF(SUM(request_count), 0)::numeric * 100), 2) as success_rate,
+    ROUND(AVG(avg_response_time_ms)::numeric, 2) as avg_response_time
 FROM ai_model_performance 
 WHERE date_tracked >= CURRENT_DATE - INTERVAL '30 days'
 GROUP BY model_name;

package/migrations/002_add_advanced_features_tables.sql

@@ -131,6 +131,10 @@ CREATE TABLE IF NOT EXISTS product_recommendations (
     created_at TIMESTAMP DEFAULT NOW()
 );
 
+-- Ensure compatibility with existing schemas
+ALTER TABLE hair_issues ADD COLUMN IF NOT EXISTS created_at TIMESTAMP DEFAULT NOW();
+ALTER TABLE product_recommendations ADD COLUMN IF NOT EXISTS created_at TIMESTAMP DEFAULT NOW();
+
 -- Indexes for better performance
 CREATE INDEX IF NOT EXISTS idx_error_logs_user_created ON error_logs(user_id, created_at);
 CREATE INDEX IF NOT EXISTS idx_error_logs_type_model ON error_logs(error_type, model_name);
@@ -142,6 +146,7 @@ CREATE INDEX IF NOT EXISTS idx_product_recommendations_user ON product_recommend
 CREATE INDEX IF NOT EXISTS idx_ab_assignments_experiment ON ab_test_assignments(experiment_id, assigned_variant);
 
 -- Views for analytics and reporting
+DROP VIEW IF EXISTS error_recovery_stats CASCADE;
 CREATE OR REPLACE VIEW error_recovery_stats AS
 SELECT 
     error_type,
@@ -150,29 +155,31 @@ SELECT
     COUNT(CASE WHEN recovery_attempted THEN 1 END) as recovery_attempts,
     COUNT(CASE WHEN recovery_successful THEN 1 END) as successful_recoveries,
     ROUND(
-        COUNT(CASE WHEN recovery_successful THEN 1 END)::float / 
-        NULLIF(COUNT(CASE WHEN recovery_attempted THEN 1 END), 0) * 100, 2
+        (COUNT(CASE WHEN recovery_successful THEN 1 END)::numeric / 
+        NULLIF(COUNT(CASE WHEN recovery_attempted THEN 1 END), 0)::numeric * 100), 2
     ) as recovery_success_rate,
     DATE(created_at) as error_date
 FROM error_logs 
 GROUP BY error_type, model_name, DATE(created_at)
 ORDER BY total_errors DESC;
 
+DROP VIEW IF EXISTS personalization_effectiveness CASCADE;
 CREATE OR REPLACE VIEW personalization_effectiveness AS
 SELECT 
     persona_assigned,
     COUNT(*) as total_interactions,
-    AVG(user_satisfaction_score) as avg_satisfaction,
+    ROUND(AVG(user_satisfaction_score)::numeric, 2) as avg_satisfaction,
     COUNT(CASE WHEN user_satisfaction_score >= 4 THEN 1 END) as satisfied_users,
     ROUND(
-        COUNT(CASE WHEN user_satisfaction_score >= 4 THEN 1 END)::float / 
-        COUNT(*) * 100, 2
+        (COUNT(CASE WHEN user_satisfaction_score >= 4 THEN 1 END)::numeric / 
+        NULLIF(COUNT(*), 0)::numeric * 100), 2
     ) as satisfaction_rate
 FROM personalization_metrics 
 WHERE persona_assigned IS NOT NULL
 GROUP BY persona_assigned
 ORDER BY avg_satisfaction DESC;
 
+DROP VIEW IF EXISTS proactive_engagement_performance CASCADE;
 CREATE OR REPLACE VIEW proactive_engagement_performance AS
 SELECT 
     c.campaign_name,
@@ -180,10 +187,10 @@ SELECT
     COUNT(h.id) as messages_sent,
     COUNT(CASE WHEN h.delivery_status = 'responded' THEN 1 END) as responses_received,
     ROUND(
-        COUNT(CASE WHEN h.delivery_status = 'responded' THEN 1 END)::float / 
-        COUNT(h.id) * 100, 2
+        (COUNT(CASE WHEN h.delivery_status = 'responded' THEN 1 END)::numeric / 
+        NULLIF(COUNT(h.id), 0)::numeric * 100), 2
     ) as response_rate,
-    AVG(h.engagement_score) as avg_engagement_score
+    ROUND(AVG(h.engagement_score)::numeric, 2) as avg_engagement_score
 FROM proactive_campaigns c
 LEFT JOIN proactive_engagement_history h ON c.id = h.campaign_id
 WHERE c.active = true

package/migrations/008_platform_identity.sql

@@ -0,0 +1,18 @@
+-- Migration 008: Platform Identity Links
+-- Maps internal canonical myavana_user_id to external provider identities
+-- (wordpress, kommunicate, mobile, widget_anon)
+
+CREATE TABLE IF NOT EXISTS identity_links (
+    id SERIAL PRIMARY KEY,
+    myavana_user_id VARCHAR(255) NOT NULL,
+    provider VARCHAR(50) NOT NULL, -- 'wordpress', 'kommunicate', 'widget_anon', 'mobile'
+    external_id VARCHAR(255) NOT NULL,
+    metadata JSONB DEFAULT '{}',
+    verified_at TIMESTAMP,
+    created_at TIMESTAMP DEFAULT NOW(),
+    updated_at TIMESTAMP DEFAULT NOW(),
+    UNIQUE(provider, external_id)
+);
+
+CREATE INDEX IF NOT EXISTS idx_identity_links_lookup ON identity_links(provider, external_id);
+CREATE INDEX IF NOT EXISTS idx_identity_links_canonical ON identity_links(myavana_user_id);

package/migrations/run_migrations.sql

@@ -145,6 +145,7 @@ BEGIN
         CREATE INDEX IF NOT EXISTS idx_ai_model_performance_date ON ai_model_performance(date_tracked);
 
         -- Views
+        DROP VIEW IF EXISTS daily_conversation_stats CASCADE;
         CREATE OR REPLACE VIEW daily_conversation_stats AS
         SELECT 
             DATE(created_at) as date,
@@ -156,14 +157,15 @@ BEGIN
         GROUP BY DATE(created_at)
         ORDER BY date DESC;
 
+        DROP VIEW IF EXISTS model_reliability_stats CASCADE;
         CREATE OR REPLACE VIEW model_reliability_stats AS
         SELECT 
             model_name,
             SUM(request_count) as total_requests,
             SUM(success_count) as total_successes,
             SUM(failure_count) as total_failures,
-            ROUND((SUM(success_count)::float / SUM(request_count)::float * 100), 2) as success_rate,
-            ROUND(AVG(avg_response_time_ms), 2) as avg_response_time
+            ROUND((SUM(success_count)::numeric / NULLIF(SUM(request_count), 0)::numeric * 100), 2) as success_rate,
+            ROUND(AVG(avg_response_time_ms)::numeric, 2) as avg_response_time
         FROM ai_model_performance 
         WHERE date_tracked >= CURRENT_DATE - INTERVAL '30 days'
         GROUP BY model_name;
@@ -265,6 +267,8 @@ BEGIN
             resolved_at TIMESTAMP
         );
 
+        ALTER TABLE hair_issues ADD COLUMN IF NOT EXISTS created_at TIMESTAMP DEFAULT NOW();
+
         -- Indexes
         CREATE INDEX IF NOT EXISTS idx_error_logs_user_created ON error_logs(user_id, created_at);
         CREATE INDEX IF NOT EXISTS idx_error_logs_type_model ON error_logs(error_type, model_name);

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "myavana-bot-test-core",
-    "version": "2.3.4",
+    "version": "2.4.0",
     "description": "Shared bot functionality with enhanced features",
     "main": "index.js",
     "scripts": {
@@ -11,13 +11,10 @@
         "lint:fix": "eslint src/ --fix"
     },
     "dependencies": {
-        "@genkit-ai/google-genai": "1.28.0",
-        "@genkit-ai/googleai": "1.28.0",
         "@google/genai": "1.39.0",
         "dotenv": "^16.4.7",
         "express-rate-limit": "^7.1.5",
         "express-slow-down": "^2.0.1",
-        "genkit": "1.28.0",
         "isomorphic-dompurify": "^2.9.0",
         "joi": "^17.11.0",
         "node-cache": "^5.1.2",

package/scripts/runMigrations.js

@@ -0,0 +1,68 @@
+const { Client } = require('pg');
+const fs = require('fs');
+const path = require('path');
+require('dotenv').config({ path: path.join(__dirname, '../../myavana/.env') });
+
+async function run() {
+  const client = new Client({
+    host: process.env.DB_HOST,
+    user: process.env.DB_USER,
+    password: process.env.DB_PASSWORD,
+    database: process.env.DB_NAME,
+    port: parseInt(process.env.DB_PORT, 10) || 5432
+  });
+
+  await client.connect();
+  console.log('Connected to PostgreSQL database at', process.env.DB_HOST);
+
+  // Ensure schema_migrations table exists
+  await client.query(`
+    CREATE TABLE IF NOT EXISTS schema_migrations (
+      id SERIAL PRIMARY KEY,
+      migration_name VARCHAR(255) NOT NULL UNIQUE,
+      applied_at TIMESTAMP DEFAULT NOW()
+    );
+  `);
+
+  const migrationsToRun = [
+    '001_add_analytics_tables.sql',
+    '002_add_advanced_features_tables.sql',
+    '008_platform_identity.sql'
+  ];
+
+  for (const file of migrationsToRun) {
+    const migrationName = path.basename(file, '.sql');
+    const checkRes = await client.query('SELECT 1 FROM schema_migrations WHERE migration_name = $1', [migrationName]);
+    if (checkRes.rows.length > 0) {
+      console.log(`Migration ${migrationName} already marked as applied, running idempotently...`);
+    } else {
+      console.log(`Applying migration ${migrationName}...`);
+    }
+
+    const filePath = path.join(__dirname, '../migrations', file);
+    const sql = fs.readFileSync(filePath, 'utf8');
+
+    await client.query('BEGIN');
+    try {
+      await client.query(sql);
+      await client.query(
+        `INSERT INTO schema_migrations (migration_name) VALUES ($1) ON CONFLICT (migration_name) DO NOTHING`,
+        [migrationName]
+      );
+      await client.query('COMMIT');
+      console.log(`✅ ${migrationName} successfully applied!`);
+    } catch (err) {
+      await client.query('ROLLBACK');
+      console.error(`❌ Migration ${migrationName} failed:`, err.message);
+      throw err;
+    }
+  }
+
+  await client.end();
+  console.log('🏁 All requested migrations applied successfully!');
+}
+
+run().catch((err) => {
+  console.error('Fatal error during migration execution:', err);
+  process.exit(1);
+});

package/src/__tests__/cacheManager.test.js

@@ -7,18 +7,15 @@ jest.mock('../database', () => ({
     redisClient: { get: mockRedisGet, set: mockRedisSet },
 }));
 
-jest.mock('../ai', () => ({}));
-jest.mock('@genkit-ai/google-genai', () => ({
-    googleAI: { model: jest.fn(() => 'mocked-model') },
-}));
-jest.mock('../config', () => ({ genkitApiKey: 'test-key' }));
-
 const mockCacheCreate = jest.fn();
-jest.mock('@google/genai', () => ({
-    GoogleGenAI: jest.fn().mockImplementation(() => ({
-        caches: { create: mockCacheCreate },
-    })),
+jest.mock('../ai', () => ({
+    client: {
+        caches: {
+            create: mockCacheCreate,
+        },
+    },
 }));
+jest.mock('../config', () => ({ genkitApiKey: 'test-key' }));
 
 const CacheManager = require('../cacheManager');
 

package/src/__tests__/hairJourneyService.test.js

@@ -0,0 +1,162 @@
+const { HairJourneyService } = require('../hairJourney/hairJourneyService');
+const { BlockType, ActionType } = require('../chatProtocol');
+
+describe('HairJourneyService', () => {
+  let service;
+
+  beforeEach(() => {
+    service = new HairJourneyService();
+  });
+
+  test('buildGoalCardBlock returns valid GOAL_CARD block', () => {
+    const goal = {
+      id: 'goal_test_1',
+      title: 'Grow 4 inches',
+      category: 'Length',
+      progressPercent: 50,
+      targetMetric: '4 Inches',
+      targetDate: 'Dec 2026'
+    };
+
+    const block = service.buildGoalCardBlock(goal);
+    expect(block.type).toBe(BlockType.GOAL_CARD);
+    expect(block.data.title).toBe('Grow 4 inches');
+    expect(block.data.progressPercent).toBe(50);
+    expect(block.actions.length).toBeGreaterThan(0);
+  });
+
+  test('buildTodayChecklistBlock returns valid TODAY_CHECKLIST block', () => {
+    const todayData = {
+      date: '2026-09-04',
+      streakDays: 5,
+      checklist: [
+        { id: 's1', title: 'Hydration Mist', completed: true },
+        { id: 's2', title: 'Deep Condition', completed: false }
+      ]
+    };
+
+    const block = service.buildTodayChecklistBlock(todayData);
+    expect(block.type).toBe(BlockType.TODAY_CHECKLIST);
+    expect(block.data.streakDays).toBe(5);
+    expect(block.data.steps.length).toBe(2);
+    expect(block.data.steps[0].completed).toBe(true);
+  });
+
+  test('buildJournalEntryBlock returns valid JOURNAL_ENTRY block with UPLOAD_PHOTO action', () => {
+    const entry = {
+      id: 123,
+      title: 'Wash Day Success',
+      notes: 'Hair felt deeply moisturized and shiny',
+      moistureLevel: 5,
+      scalpState: 'Healthy',
+      photos: ['https://example.com/photo1.jpg']
+    };
+
+    const block = service.buildJournalEntryBlock(entry);
+    expect(block.type).toBe(BlockType.JOURNAL_ENTRY);
+    expect(block.data.title).toBe('Wash Day Success');
+    expect(block.data.moistureLevel).toBe(5);
+    expect(block.data.photos.length).toBe(1);
+
+    const uploadAction = block.actions.find(a => a.type === ActionType.UPLOAD_PHOTO);
+    expect(uploadAction).toBeDefined();
+    expect(uploadAction.payload.entryId).toBe(123);
+  });
+
+  test('buildHairProfileBlock preserves nulls and does not fabricate Type 4 or Normal porosity', () => {
+    const emptyProfile = {
+      hairType: null,
+      porosity: null,
+      hairConcerns: []
+    };
+    const block = service.buildHairProfileBlock(emptyProfile);
+    expect(block).toBeDefined();
+    expect(block.data.hairType).toBeNull();
+    expect(block.data.porosity).toBeNull();
+    expect(block.data.regimen).toBeNull();
+  });
+
+  test('buildHairProfileBlock returns null when profile is unavailable', () => {
+    const unavailableProfile = { available: false, error: 'API offline' };
+    const block = service.buildHairProfileBlock(unavailableProfile);
+    expect(block).toBeNull();
+  });
+
+  test('honest unavailable handling when backend is offline', async () => {
+    // Service with offline/unreachable provider
+    const offlineProvider = {
+      getGoals: jest.fn().mockResolvedValue({ available: false, error: 'offline', goals: [] }),
+      getTodayData: jest.fn().mockResolvedValue({ available: false, error: 'offline', checklist: [] }),
+      getJournalEntries: jest.fn().mockResolvedValue({ available: false, error: 'offline', items: [] }),
+      getProfile: jest.fn().mockResolvedValue({ available: false, error: 'offline' })
+    };
+    const offlineService = new HairJourneyService({ provider: offlineProvider });
+
+    const goalsRes = await offlineService.getGoalsWithBlocks('user_123');
+    expect(goalsRes.result.available).toBe(false);
+    expect(goalsRes.blocks).toEqual([]);
+
+    const todayRes = await offlineService.getTodayWithBlocks('user_123');
+    expect(todayRes.result.available).toBe(false);
+    expect(todayRes.blocks).toEqual([]);
+
+    const profileRes = await offlineService.getProfileWithBlocks('user_123');
+    expect(profileRes.result.available).toBe(false);
+    expect(profileRes.blocks).toEqual([]);
+  });
+
+  test('getGoalsWithBlocks returns goals and blocks when provider has authentic data', async () => {
+    const mockProvider = {
+      getGoals: jest.fn().mockResolvedValue({
+        available: true,
+        goals: [
+          { id: 'g1', title: 'Retain 4 Inches Length', progressPercent: 68, targetMetric: '14.5 in', targetDate: '2026-12-15' }
+        ]
+      })
+    };
+    const activeService = new HairJourneyService({ provider: mockProvider });
+    const { result, blocks } = await activeService.getGoalsWithBlocks('test_user');
+    expect(result.available).toBe(true);
+    expect(blocks.length).toBe(1);
+    expect(blocks[0].type).toBe(BlockType.GOAL_CARD);
+    expect(blocks[0].data.title).toBe('Retain 4 Inches Length');
+    expect(blocks[0].data.progressPercent).toBe(68);
+  });
+
+  test('getTodayWithBlocks returns today checklist block when provider has authentic data', async () => {
+    const mockProvider = {
+      getTodayData: jest.fn().mockResolvedValue({
+        available: true,
+        streakDays: 9,
+        checklist: [{ id: 's1', title: 'Morning Hydration', completed: true }]
+      })
+    };
+    const activeService = new HairJourneyService({ provider: mockProvider });
+    const { result, blocks } = await activeService.getTodayWithBlocks('test_user');
+    expect(result.available).toBe(true);
+    expect(blocks.length).toBe(1);
+    expect(blocks[0].type).toBe(BlockType.TODAY_CHECKLIST);
+    expect(blocks[0].data.streakDays).toBe(9);
+  });
+
+  test('getProfileWithBlocks returns authentic hair profile without fabrication', async () => {
+    const mockProvider = {
+      getProfile: jest.fn().mockResolvedValue({
+        available: true,
+        hairType: '4A',
+        porosity: 'Medium',
+        elasticity: 'Medium',
+        strandDiameter: 'Medium',
+        hairConcerns: ['Moisture Retention']
+      })
+    };
+    const activeService = new HairJourneyService({ provider: mockProvider });
+    const { result, blocks } = await activeService.getProfileWithBlocks('test_user');
+    expect(result.available).toBe(true);
+    expect(result.hairType).toBe('4A');
+    expect(result.porosity).toBe('Medium');
+    expect(blocks.length).toBe(1);
+    expect(blocks[0].data.hairType).toBe('4A');
+    expect(blocks[0].data.porosity).toBe('Medium');
+  });
+});

package/src/agentMemory.js

@@ -4,14 +4,12 @@
 // the existing AWS/GCP infra. Extraction follows the same LLM-structured-extraction
 // pattern already used by postProcessConversation/classifyAndSavePersona.
 const ai = require('./ai');
-const { googleAI } = require('@genkit-ai/google-genai');
 const { pgClient } = require('./database');
 
-const EMBEDDER = googleAI.embedder('gemini-embedding-001'); // 768-dim output, matches agent_memories.embedding
 const DUPLICATE_DISTANCE_THRESHOLD = 0.15; // cosine distance below this = treat as the same memory
 
 async function embedText(text) {
-    const [{ embedding }] = await ai.embed({ embedder: EMBEDDER, content: text });
+    const [{ embedding }] = await ai.embed({ embedder: 'gemini-embedding-001', content: text });
     return `[${embedding.join(',')}]`;
 }
 
@@ -44,7 +42,7 @@ const extractAndStoreMemories = async (userId, conversationId, chatHistory) => {
         if (!latestUserTurn?.content) return;
 
         const chat = ai.chat({
-            model: googleAI.model('gemini-3.6-flash'),
+            model: 'gemini-2.5-flash',
             config: { temperature: 0.3 },
         });
         const { output } = await chat.send(extractionPrompt(chatHistory, latestUserTurn.content));