myavana-bot-test-core 2.2.0 → 2.3.0

package/src/__tests__/conversation.test.js

@@ -0,0 +1,151 @@
+const mockQuery = jest.fn();
+const mockRedisGet = jest.fn();
+const mockRedisSet = jest.fn();
+
+jest.mock('../database', () => ({
+    pgClient: { query: mockQuery },
+    redisClient: { get: mockRedisGet, set: mockRedisSet },
+}));
+
+jest.mock('../ai', () => ({
+    chat: jest.fn(),
+}));
+
+jest.mock('@genkit-ai/google-genai', () => ({
+    googleAI: { model: jest.fn(() => 'mocked-model') },
+}));
+
+const {
+    saveConversationSummary,
+    getAllConversationsSummary,
+    getConversationHistory,
+    saveConversation,
+} = require('../conversation');
+
+beforeEach(() => {
+    jest.clearAllMocks();
+});
+
+describe('saveConversationSummary', () => {
+    test('inserts/updates DB and caches in Redis', async () => {
+        mockQuery.mockResolvedValue({ rows: [{ conversation_id: 'c1', summary: 'sum' }] });
+        mockRedisSet.mockResolvedValue('OK');
+
+        const result = await saveConversationSummary('c1', 'u1', 'sum');
+
+        expect(mockQuery).toHaveBeenCalledWith(
+            expect.stringContaining('INSERT INTO conversations'),
+            ['c1', 'u1', 'sum']
+        );
+        expect(mockRedisSet).toHaveBeenCalledWith('summary:u1', 'sum', { EX: 3600 });
+        expect(result).toEqual({ conversation_id: 'c1', summary: 'sum' });
+    });
+
+    test('throws on DB error', async () => {
+        mockQuery.mockRejectedValue(new Error('DB error'));
+        await expect(saveConversationSummary('c1', 'u1', 'sum')).rejects.toThrow('DB error');
+    });
+});
+
+describe('getAllConversationsSummary', () => {
+    test('returns cached summary from Redis', async () => {
+        mockRedisGet.mockResolvedValue('cached summary');
+
+        const result = await getAllConversationsSummary('u1');
+
+        expect(result).toBe('cached summary');
+        expect(mockQuery).not.toHaveBeenCalled();
+    });
+
+    test('fetches from DB on Redis miss and caches result', async () => {
+        mockRedisGet.mockResolvedValue(null);
+        mockQuery.mockResolvedValue({ rows: [{ summary: 'db summary' }] });
+        mockRedisSet.mockResolvedValue('OK');
+
+        const result = await getAllConversationsSummary('u1');
+
+        expect(result).toBe('db summary');
+        expect(mockRedisSet).toHaveBeenCalledWith('summary:u1', 'db summary', { EX: 3600 });
+    });
+
+    test('returns fallback string when no summary exists', async () => {
+        mockRedisGet.mockResolvedValue(null);
+        mockQuery.mockResolvedValue({ rows: [] });
+
+        const result = await getAllConversationsSummary('u1');
+
+        expect(result).toBe('conversation summary not available.');
+    });
+
+    test('returns fallback string on error', async () => {
+        mockRedisGet.mockRejectedValue(new Error('Redis down'));
+
+        const result = await getAllConversationsSummary('u1');
+
+        expect(result).toBe('conversation summary not available.');
+    });
+});
+
+describe('getConversationHistory', () => {
+    test('returns parsed history from Redis cache', async () => {
+        const history = [{ role: 'user', content: 'hi' }];
+        mockRedisGet.mockResolvedValue(JSON.stringify({ chatHistory: history }));
+
+        const result = await getConversationHistory('conv1', 'u1');
+
+        expect(result).toEqual(history);
+        expect(mockQuery).not.toHaveBeenCalled();
+    });
+
+    test('fetches from DB on Redis miss and caches result', async () => {
+        const history = [{ role: 'user', content: 'hi' }];
+        mockRedisGet.mockResolvedValue(null);
+        mockQuery.mockResolvedValue({ rows: [{ chat_history: history }] });
+        mockRedisSet.mockResolvedValue('OK');
+
+        const result = await getConversationHistory('conv1', 'u1');
+
+        expect(result).toEqual(history);
+        expect(mockRedisSet).toHaveBeenCalledWith(
+            'conversation:conv1',
+            JSON.stringify({ chatHistory: history })
+        );
+    });
+
+    test('returns empty array for new conversation', async () => {
+        mockRedisGet.mockResolvedValue(null);
+        mockQuery.mockResolvedValue({ rows: [] });
+
+        const result = await getConversationHistory('conv1', 'u1');
+
+        expect(result).toEqual([]);
+    });
+
+    test('returns empty array on error', async () => {
+        mockRedisGet.mockRejectedValue(new Error('Redis down'));
+
+        const result = await getConversationHistory('conv1', 'u1');
+
+        expect(result).toEqual([]);
+    });
+});
+
+describe('saveConversation', () => {
+    test('saves to DB and updates Redis cache', async () => {
+        const history = [{ role: 'user', content: 'hi' }];
+        mockQuery.mockResolvedValue({ rows: [{ conversation_id: 'c1' }] });
+        mockRedisSet.mockResolvedValue('OK');
+
+        const result = await saveConversation('c1', 'u1', history, 'summary');
+
+        expect(mockQuery).toHaveBeenCalledWith(
+            expect.stringContaining('INSERT INTO conversations'),
+            ['c1', 'u1', JSON.stringify(history), 'summary']
+        );
+        expect(mockRedisSet).toHaveBeenCalledWith(
+            'conversation:c1',
+            JSON.stringify({ chatHistory: history })
+        );
+        expect(result).toEqual({ conversation_id: 'c1' });
+    });
+});

package/src/__tests__/conversationDriver.test.js

@@ -0,0 +1,233 @@
+const {
+    inferStage,
+    analyzeAIQuestions,
+    getDepthCategory,
+    buildDrivingDirective,
+    getConversationDirective,
+    STAGES,
+} = require('../conversationDriver');
+
+// ---------------------------------------------------------------------------
+// Test helpers
+// ---------------------------------------------------------------------------
+
+const user = (content) => ({ role: 'user', content });
+const ai   = (content) => ({ role: 'model', content });
+
+// ---------------------------------------------------------------------------
+// inferStage
+// ---------------------------------------------------------------------------
+
+describe('inferStage', () => {
+    test('detects stage 5 from desperation keywords', () => {
+        expect(inferStage([user('I am so overwhelmed and frustrated with my hair')])).toBe(5);
+    });
+
+    test('detects stage 6 from damage keywords', () => {
+        expect(inferStage([user('I have so much heat damage and breakage')])).toBe(6);
+    });
+
+    test('detects stage 1 from big chop keywords', () => {
+        expect(inferStage([user('I just did my big chop yesterday!')])).toBe(1);
+    });
+
+    test('detects stage 8 from nirvana keywords', () => {
+        expect(inferStage([user('I love my routine and my hair is healthy and happy')])).toBe(8);
+    });
+
+    test('returns null when no keywords match', () => {
+        expect(inferStage([user('Hello there')])).toBeNull();
+    });
+
+    test('returns null for empty history', () => {
+        expect(inferStage([])).toBeNull();
+    });
+
+    test('only looks at last 4 user messages (old keywords ignored)', () => {
+        const old = user('I just did my big chop'); // stage 1
+        const recent = user('I am overwhelmed');     // stage 5
+        const history = [old, ai('response'), ai('r2'), ai('r3'), ai('r4'), recent];
+        // Recent stage 5 wins over old stage 1
+        expect(inferStage(history)).toBe(5);
+    });
+});
+
+// ---------------------------------------------------------------------------
+// analyzeAIQuestions
+// ---------------------------------------------------------------------------
+
+describe('analyzeAIQuestions', () => {
+    test('counts turns with questions correctly', () => {
+        const history = [
+            user('hi'),
+            ai('Hello! What is your hair type?'),
+            user('4c'),
+            ai('Great! How long have you been natural?'),
+            user('2 years'),
+            ai('Wonderful. Here are some tips.'),
+        ];
+        const stats = analyzeAIQuestions(history, 3);
+        expect(stats.total).toBe(3);
+        expect(stats.withQuestion).toBe(2);
+        expect(stats.lastTurnHadQuestion).toBe(false);
+    });
+
+    test('lastTurnHadQuestion is true when last AI turn has a question', () => {
+        const history = [user('hi'), ai('What is your hair type?')];
+        const stats = analyzeAIQuestions(history);
+        expect(stats.lastTurnHadQuestion).toBe(true);
+    });
+
+    test('returns zeros for empty history', () => {
+        const stats = analyzeAIQuestions([]);
+        expect(stats.total).toBe(0);
+        expect(stats.withQuestion).toBe(0);
+        expect(stats.lastTurnHadQuestion).toBe(false);
+    });
+});
+
+// ---------------------------------------------------------------------------
+// getDepthCategory
+// ---------------------------------------------------------------------------
+
+describe('getDepthCategory', () => {
+    test('opening: 0 user turns', () => {
+        expect(getDepthCategory([])).toBe('opening');
+    });
+
+    test('opening: 1 user turn', () => {
+        expect(getDepthCategory([user('hi')])).toBe('opening');
+    });
+
+    test('exploring: 2-3 user turns', () => {
+        expect(getDepthCategory([user('a'), user('b')])).toBe('exploring');
+        expect(getDepthCategory([user('a'), user('b'), user('c')])).toBe('exploring');
+    });
+
+    test('deepening: 4-7 user turns', () => {
+        const h = Array.from({ length: 5 }, () => user('msg'));
+        expect(getDepthCategory(h)).toBe('deepening');
+    });
+
+    test('action-ready: 8+ user turns', () => {
+        const h = Array.from({ length: 8 }, () => user('msg'));
+        expect(getDepthCategory(h)).toBe('action-ready');
+    });
+});
+
+// ---------------------------------------------------------------------------
+// buildDrivingDirective
+// ---------------------------------------------------------------------------
+
+describe('buildDrivingDirective', () => {
+    test('opening with no stage → ask about hair type', () => {
+        const result = buildDrivingDirective({
+            stage: null, depth: 'opening',
+            questionStats: { total: 0, withQuestion: 0, lastTurnHadQuestion: false },
+            personaType: null,
+        });
+        expect(result).toMatch(/ask one open question/);
+    });
+
+    test('exploring, AI did not ask last turn → prompt to ask follow-up', () => {
+        const result = buildDrivingDirective({
+            stage: null, depth: 'exploring',
+            questionStats: { total: 1, withQuestion: 0, lastTurnHadQuestion: false },
+            personaType: null,
+        });
+        expect(result).toMatch(/follow-up question/);
+    });
+
+    test('exploring, AI already asked → includes stage context when stage known', () => {
+        const result = buildDrivingDirective({
+            stage: 3, depth: 'exploring',
+            questionStats: { total: 1, withQuestion: 1, lastTurnHadQuestion: true },
+            personaType: null,
+        });
+        expect(result).toMatch(/Experimenting/);
+    });
+
+    test('deepening, AI never asked → surfaces momentum directive', () => {
+        const result = buildDrivingDirective({
+            stage: null, depth: 'deepening',
+            questionStats: { total: 3, withQuestion: 0, lastTurnHadQuestion: false },
+            personaType: null,
+        });
+        expect(result).toMatch(/forward momentum/);
+    });
+
+    test('deepening, high-need stage (5) → introduces Myavana service', () => {
+        const result = buildDrivingDirective({
+            stage: 5, depth: 'deepening',
+            questionStats: { total: 3, withQuestion: 2, lastTurnHadQuestion: true },
+            personaType: null,
+        });
+        expect(result).toMatch(/Myavana service/);
+    });
+
+    test('action-ready, stage 8 → celebrate and maintenance', () => {
+        const result = buildDrivingDirective({
+            stage: 8, depth: 'action-ready',
+            questionStats: { total: 5, withQuestion: 3, lastTurnHadQuestion: true },
+            personaType: null,
+        });
+        expect(result).toMatch(/celebrate/);
+    });
+
+    test('overwhelmed persona softens action directive', () => {
+        const result = buildDrivingDirective({
+            stage: 6, depth: 'deepening',
+            questionStats: { total: 3, withQuestion: 2, lastTurnHadQuestion: true },
+            personaType: 'overwhelmed',
+        });
+        expect(result).toMatch(/empathy first/);
+        expect(result).not.toMatch(/introduce a relevant Myavana service/);
+    });
+
+    test('returns empty string when no directive applies', () => {
+        // exploring + already asked → no stage context when stage is null
+        const result = buildDrivingDirective({
+            stage: null, depth: 'exploring',
+            questionStats: { total: 1, withQuestion: 1, lastTurnHadQuestion: true },
+            personaType: null,
+        });
+        expect(result).toBe('');
+    });
+});
+
+// ---------------------------------------------------------------------------
+// getConversationDirective (integration)
+// ---------------------------------------------------------------------------
+
+describe('getConversationDirective', () => {
+    test('returns first-message directive for empty history', () => {
+        const result = getConversationDirective([]);
+        expect(result).toMatch(/first message/);
+    });
+
+    test('returns non-empty string for a real conversation', () => {
+        const history = [
+            user('My hair is so damaged from bleaching'),
+            ai('I understand, bleach can really stress your strands. How long ago did you bleach?'),
+            user('About 3 months ago. It keeps breaking off'),
+            ai('Breakage after bleach is very common. Are you using any protein treatments?'),
+            user('No, I had no idea I needed that'),
+        ];
+        const result = getConversationDirective(history, null);
+        expect(typeof result).toBe('string');
+        expect(result.length).toBeGreaterThan(0);
+    });
+
+    test('wraps directive in bracket format', () => {
+        const result = getConversationDirective([user('hi')], null);
+        if (result) {
+            expect(result).toMatch(/^\[Conversation driver:/);
+            expect(result).toMatch(/\]\n$/);
+        }
+    });
+
+    test('does not throw when personaType is null or undefined', () => {
+        expect(() => getConversationDirective([user('hello')], null)).not.toThrow();
+        expect(() => getConversationDirective([user('hello')], undefined)).not.toThrow();
+    });
+});

package/src/__tests__/messageContextBuilder.test.js

@@ -0,0 +1,192 @@
+jest.mock('../personaClassifier', () => ({
+    getUserPersona:   jest.fn(),
+    buildContextBlock: jest.fn(),
+}));
+
+jest.mock('../conversationDriver', () => ({
+    getConversationDirective: jest.fn().mockReturnValue(''),
+    inferStage:               jest.fn().mockReturnValue(null),
+    extractTrendSummary:      jest.fn().mockReturnValue(null),
+}));
+
+jest.mock('../trendManager', () => ({
+    getTrendContext: jest.fn().mockResolvedValue(''),
+}));
+
+jest.mock('../agentMemory', () => ({
+    retrieveRelevantMemories: jest.fn().mockResolvedValue([]),
+}));
+
+const { getUserPersona, buildContextBlock } = require('../personaClassifier');
+const { getConversationDirective, inferStage, extractTrendSummary } = require('../conversationDriver');
+const { getTrendContext } = require('../trendManager');
+const { retrieveRelevantMemories } = require('../agentMemory');
+const { buildMessageContext } = require('../messageContextBuilder');
+
+beforeEach(() => {
+    jest.clearAllMocks();
+    // resetMocks (jest.config.js) wipes the jest.mock() factory default before each test,
+    // so give every test a harmless empty-memory default; tests exercising memory override it.
+    retrieveRelevantMemories.mockResolvedValue([]);
+});
+
+describe('buildMessageContext', () => {
+    test('returns persona block when persona exists and no trend or driver', async () => {
+        const persona = { personaType: 'overwhelmed', communicationStyle: 'nurturing', toneDirectives: [] };
+        getUserPersona.mockResolvedValue(persona);
+        buildContextBlock.mockReturnValue('[User persona: overwhelmed, style: nurturing]\n');
+        getTrendContext.mockResolvedValue('');
+        getConversationDirective.mockReturnValue('');
+
+        const result = await buildMessageContext('u1', []);
+        expect(result).toBe('[User persona: overwhelmed, style: nurturing]\n');
+        // hasTrends=false because trendContext is empty
+        expect(buildContextBlock).toHaveBeenCalledWith(persona, false);
+    });
+
+    test('passes hasTrends=true to buildContextBlock when trend context exists', async () => {
+        const persona = { personaType: 'researcher', communicationStyle: 'professional', toneDirectives: [] };
+        getUserPersona.mockResolvedValue(persona);
+        buildContextBlock.mockReturnValue('[User persona: researcher, style: professional]\n');
+        getTrendContext.mockResolvedValue('[Trending in hair care: scalp detox]\n');
+        getConversationDirective.mockReturnValue('');
+
+        await buildMessageContext('u1', []);
+        expect(buildContextBlock).toHaveBeenCalledWith(persona, true);
+    });
+
+    test('combines all three blocks when all present', async () => {
+        const persona = { personaType: 'explorer', communicationStyle: 'casual', toneDirectives: [] };
+        getUserPersona.mockResolvedValue(persona);
+        buildContextBlock.mockReturnValue('[User persona: explorer, style: casual]\n');
+        getTrendContext.mockResolvedValue('[Trending in hair care: rice water]\n');
+        getConversationDirective.mockReturnValue('[Conversation driver: ask a follow-up]\n');
+
+        const result = await buildMessageContext('u1', [{ role: 'user', content: 'hi' }]);
+        expect(result).toBe(
+            '[User persona: explorer, style: casual]\n' +
+            '[Trending in hair care: rice water]\n' +
+            '[Conversation driver: ask a follow-up]\n'
+        );
+    });
+
+    test('returns driver directive alone when no persona saved', async () => {
+        getUserPersona.mockResolvedValue(null);
+        getTrendContext.mockResolvedValue('');
+        getConversationDirective.mockReturnValue('[Conversation driver: first message directive]\n');
+
+        const result = await buildMessageContext('u1');
+        expect(result).toBe('[Conversation driver: first message directive]\n');
+        expect(buildContextBlock).not.toHaveBeenCalled();
+    });
+
+    test('returns empty string when all sources return nothing', async () => {
+        getUserPersona.mockResolvedValue(null);
+        getTrendContext.mockResolvedValue('');
+        getConversationDirective.mockReturnValue('');
+
+        expect(await buildMessageContext('u1')).toBe('');
+    });
+
+    test('passes inferred stage and personaType to getTrendContext', async () => {
+        const persona = { personaType: 'overwhelmed', communicationStyle: 'nurturing', toneDirectives: [] };
+        getUserPersona.mockResolvedValue(persona);
+        buildContextBlock.mockReturnValue('');
+        inferStage.mockReturnValue(5);
+        getTrendContext.mockResolvedValue('');
+        getConversationDirective.mockReturnValue('');
+
+        await buildMessageContext('u1', [{ role: 'user', content: 'help' }]);
+        expect(getTrendContext).toHaveBeenCalledWith(5, 'overwhelmed');
+    });
+
+    test('passes trendSummary and personaType to getConversationDirective', async () => {
+        getUserPersona.mockResolvedValue(null);
+        getTrendContext.mockResolvedValue('[Trending in hair care: scalp detox]\n');
+        extractTrendSummary.mockReturnValue('scalp detox');
+        getConversationDirective.mockReturnValue('');
+
+        const history = [{ role: 'user', content: 'help me' }];
+        await buildMessageContext('u1', history);
+        expect(getConversationDirective).toHaveBeenCalledWith(history, null, 'scalp detox');
+    });
+
+    test('does not throw when getUserPersona fails — still runs trend and driver', async () => {
+        getUserPersona.mockRejectedValue(new Error('Redis down'));
+        getTrendContext.mockResolvedValue('');
+        getConversationDirective.mockReturnValue('[Conversation driver: directive]\n');
+
+        const result = await buildMessageContext('u1');
+        expect(result).toBe('[Conversation driver: directive]\n');
+    });
+
+    test('does not throw when trendManager fails — still returns persona and driver', async () => {
+        const persona = { personaType: 'engaged', communicationStyle: 'casual', toneDirectives: [] };
+        getUserPersona.mockResolvedValue(persona);
+        buildContextBlock.mockReturnValue('[User persona: engaged, style: casual]\n');
+        getTrendContext.mockRejectedValue(new Error('trend error'));
+        getConversationDirective.mockReturnValue('');
+
+        const result = await buildMessageContext('u1');
+        expect(result).toBe('[User persona: engaged, style: casual]\n');
+    });
+
+    test('does not throw when conversationDriver fails — still returns persona and trend', async () => {
+        const persona = { personaType: 'engaged', communicationStyle: 'casual', toneDirectives: [] };
+        getUserPersona.mockResolvedValue(persona);
+        buildContextBlock.mockReturnValue('[User persona: engaged, style: casual]\n');
+        getTrendContext.mockResolvedValue('[Trending in hair care: rice water]\n');
+        getConversationDirective.mockImplementation(() => { throw new Error('driver error'); });
+
+        const result = await buildMessageContext('u1');
+        expect(result).toBe('[User persona: engaged, style: casual]\n[Trending in hair care: rice water]\n');
+    });
+
+    test('appends a memory block when relevant memories are found', async () => {
+        getUserPersona.mockResolvedValue(null);
+        getTrendContext.mockResolvedValue('');
+        getConversationDirective.mockReturnValue('');
+        retrieveRelevantMemories.mockResolvedValue(['prefers sulfate-free products', 'goal: length retention']);
+
+        const result = await buildMessageContext('u1', [{ role: 'user', content: 'what should I use?' }]);
+        expect(result).toContain('Relevant memory:');
+        expect(result).toContain('- prefers sulfate-free products');
+        expect(result).toContain('- goal: length retention');
+    });
+
+    test('passes currentMessage to retrieveRelevantMemories when provided', async () => {
+        getUserPersona.mockResolvedValue(null);
+        getTrendContext.mockResolvedValue('');
+        getConversationDirective.mockReturnValue('');
+        retrieveRelevantMemories.mockResolvedValue([]);
+
+        await buildMessageContext('u1', [], 'what oils should I use?');
+        expect(retrieveRelevantMemories).toHaveBeenCalledWith('u1', 'what oils should I use?');
+    });
+
+    test('falls back to the last user turn when currentMessage is omitted', async () => {
+        getUserPersona.mockResolvedValue(null);
+        getTrendContext.mockResolvedValue('');
+        getConversationDirective.mockReturnValue('');
+        retrieveRelevantMemories.mockResolvedValue([]);
+
+        const history = [
+            { role: 'assistant', content: 'hi there' },
+            { role: 'user', content: 'my hair is dry' },
+        ];
+        await buildMessageContext('u1', history);
+        expect(retrieveRelevantMemories).toHaveBeenCalledWith('u1', 'my hair is dry');
+    });
+
+    test('does not throw when memory retrieval fails — still returns other blocks', async () => {
+        const persona = { personaType: 'engaged', communicationStyle: 'casual', toneDirectives: [] };
+        getUserPersona.mockResolvedValue(persona);
+        buildContextBlock.mockReturnValue('[User persona: engaged, style: casual]\n');
+        getTrendContext.mockResolvedValue('');
+        getConversationDirective.mockReturnValue('');
+        retrieveRelevantMemories.mockRejectedValue(new Error('pgvector error'));
+
+        const result = await buildMessageContext('u1');
+        expect(result).toBe('[User persona: engaged, style: casual]\n');
+    });
+});