@aj-archipelago/cortex 1.3.65 → 1.3.67

package/tests/unit/core/pathwayManagerWithFiles.test.js

@@ -0,0 +1,256 @@
+/**
+ * PathwayManager File Handling Tests
+ * 
+ * This test suite validates the PathwayManager's file handling functionality, specifically
+ * testing how the manager processes and transforms pathway prompts that include file attachments.
+ * 
+ * Key functionality tested:
+ * - File hash transformation from 'files' to 'fileHashes' property
+ * - Collection and deduplication of file hashes at the pathway level
+ * - Backward compatibility with legacy string-based prompts without file attachments
+ * - Handling of edge cases (null, undefined, empty file arrays)
+ * - Prompt object creation with file metadata
+ * 
+ * The PathwayManager allows prompts to reference files by their hashes, which are then
+ * processed and made available to the execution context. This test suite ensures that
+ * file metadata is correctly preserved, transformed, and aggregated during pathway processing.
+ * 
+ * Test scenarios covered:
+ * 1. Prompts with multiple file attachments
+ * 2. Prompts with empty or missing file arrays
+ * 3. Legacy string prompts (no file support)
+ * 4. Duplicate file hash deduplication
+ * 5. Null/undefined file handling
+ * 6. Direct prompt object creation with files
+ */
+
+import test from 'ava';
+import PathwayManager from '../../../lib/pathwayManager.js';
+
+// Mock config for PathwayManager
+const mockConfig = {
+    storageType: 'local',
+    filePath: './test-pathways.json',
+    publishKey: 'test-key'
+};
+
+// Mock base pathway
+const mockBasePathway = {
+    name: 'base',
+    prompt: '{{text}}',
+    systemPrompt: '',
+    inputParameters: {},
+    typeDef: 'type Test { test: String }',
+    rootResolver: () => {},
+    resolver: () => {}
+};
+
+// Mock storage strategy
+class MockStorageStrategy {
+    async load() {
+        return {};
+    }
+    
+    async save(data) {
+        // Do nothing
+    }
+    
+    async getLastModified() {
+        return Date.now();
+    }
+}
+
+test('pathwayManager handles prompt format with files correctly', async t => {
+    const pathwayManager = new PathwayManager(mockConfig, mockBasePathway);
+    
+    // Replace storage with mock
+    pathwayManager.storage = new MockStorageStrategy();
+    
+    // Test prompts with files
+    const pathwayWithFiles = {
+        prompt: [
+            {
+                name: 'Analyze Document',
+                prompt: 'Please analyze the provided document',
+                files: ['abc123def456', 'def456ghi789']
+            },
+            {
+                name: 'Summarize Text',
+                prompt: 'Please summarize the text',
+                files: []
+            },
+            {
+                name: 'Simple Task',
+                prompt: 'Perform a simple task'
+                // No files property
+            }
+        ],
+        systemPrompt: 'You are a helpful assistant'
+    };
+    
+    // Test transformPrompts method
+    const transformedPathway = await pathwayManager.transformPrompts(pathwayWithFiles);
+    
+    // Verify the transformed pathway structure
+    t.truthy(transformedPathway);
+    t.true(Array.isArray(transformedPathway.prompt));
+    t.is(transformedPathway.prompt.length, 3);
+    
+    // Verify first prompt with files
+    const firstPrompt = transformedPathway.prompt[0];
+    t.is(firstPrompt.name, 'Analyze Document');
+    t.truthy(firstPrompt.fileHashes);
+    t.deepEqual(firstPrompt.fileHashes, ['abc123def456', 'def456ghi789']);
+    
+    // Verify second prompt with empty files
+    const secondPrompt = transformedPathway.prompt[1];
+    t.is(secondPrompt.name, 'Summarize Text');
+    t.falsy(secondPrompt.fileHashes); // Empty array results in no fileHashes property
+    
+    // Verify third prompt without files property
+    const thirdPrompt = transformedPathway.prompt[2];
+    t.is(thirdPrompt.name, 'Simple Task');
+    t.falsy(thirdPrompt.fileHashes);
+    
+    // Verify pathway-level file hashes collection
+    t.truthy(transformedPathway.fileHashes);
+    t.deepEqual(transformedPathway.fileHashes, ['abc123def456', 'def456ghi789']);
+});
+
+test('pathwayManager handles legacy string prompts correctly', async t => {
+    const pathwayManager = new PathwayManager(mockConfig, mockBasePathway);
+    
+    // Replace storage with mock
+    pathwayManager.storage = new MockStorageStrategy();
+    
+    // Test legacy string prompts
+    const legacyPathway = {
+        prompt: [
+            'Please analyze the data',
+            'Summarize the findings'
+        ],
+        systemPrompt: 'You are a helpful assistant'
+    };
+    
+    // Test transformPrompts method
+    const transformedPathway = await pathwayManager.transformPrompts(legacyPathway);
+    
+    // Verify the transformed pathway structure
+    t.truthy(transformedPathway);
+    t.true(Array.isArray(transformedPathway.prompt));
+    t.is(transformedPathway.prompt.length, 2);
+    
+    // Verify prompts don't have file hashes
+    transformedPathway.prompt.forEach(prompt => {
+        t.falsy(prompt.fileHashes);
+    });
+    
+    // Verify no pathway-level file hashes
+    t.falsy(transformedPathway.fileHashes);
+});
+
+test('pathwayManager removes duplicate file hashes at pathway level', async t => {
+    const pathwayManager = new PathwayManager(mockConfig, mockBasePathway);
+    
+    // Replace storage with mock
+    pathwayManager.storage = new MockStorageStrategy();
+    
+    // Test prompts with duplicate file hashes
+    const pathwayWithDuplicateFiles = {
+        prompt: [
+            {
+                name: 'First Task',
+                prompt: 'Analyze document 1',
+                files: ['abc123def456', 'def456ghi789']
+            },
+            {
+                name: 'Second Task', 
+                prompt: 'Analyze document 2',
+                files: ['abc123def456', 'ghi789jkl012'] // abc123def456 is duplicate
+            }
+        ],
+        systemPrompt: 'You are a helpful assistant'
+    };
+    
+    // Test transformPrompts method
+    const transformedPathway = await pathwayManager.transformPrompts(pathwayWithDuplicateFiles);
+    
+    // Verify pathway-level file hashes are deduplicated
+    t.truthy(transformedPathway.fileHashes);
+    t.deepEqual(transformedPathway.fileHashes, ['abc123def456', 'def456ghi789', 'ghi789jkl012']);
+    t.is(transformedPathway.fileHashes.length, 3); // Should not have duplicates
+});
+
+test('pathwayManager handles null and undefined files gracefully', async t => {
+    const pathwayManager = new PathwayManager(mockConfig, mockBasePathway);
+    
+    // Replace storage with mock
+    pathwayManager.storage = new MockStorageStrategy();
+    
+    // Test prompts with null/undefined files
+    const pathwayWithNullFiles = {
+        prompt: [
+            {
+                name: 'Task with null files',
+                prompt: 'Do something', 
+                files: null
+            },
+            {
+                name: 'Task with undefined files',
+                prompt: 'Do something else'
+                // files property is undefined
+            }
+        ],
+        systemPrompt: 'You are a helpful assistant'
+    };
+    
+    // Test transformPrompts method
+    const transformedPathway = await pathwayManager.transformPrompts(pathwayWithNullFiles);
+    
+    // Verify the transformation handles null/undefined gracefully
+    t.truthy(transformedPathway);
+    t.true(Array.isArray(transformedPathway.prompt));
+    
+    // Both prompts should have empty or undefined fileHashes
+    transformedPathway.prompt.forEach(prompt => {
+        t.true(!prompt.fileHashes || prompt.fileHashes.length === 0);
+    });
+    
+    // No pathway-level file hashes should be set
+    t.falsy(transformedPathway.fileHashes);
+});
+
+test('pathwayManager _createPromptObject handles files correctly', t => {
+    const pathwayManager = new PathwayManager(mockConfig, mockBasePathway);
+    
+    // Test with object prompt containing files
+    const promptWithFiles = {
+        name: 'Test Prompt',
+        prompt: 'Analyze this document',
+        files: ['file1hash', 'file2hash']
+    };
+    
+    const createdPrompt = pathwayManager._createPromptObject(promptWithFiles, 'System prompt');
+    
+    t.is(createdPrompt.name, 'Test Prompt');
+    t.truthy(createdPrompt.fileHashes);
+    t.deepEqual(createdPrompt.fileHashes, ['file1hash', 'file2hash']);
+    
+    // Test with string prompt (no files)
+    const stringPrompt = 'Simple text prompt';
+    const createdStringPrompt = pathwayManager._createPromptObject(stringPrompt, 'System prompt', 'Default Name');
+    
+    t.is(createdStringPrompt.name, 'Default Name');
+    t.falsy(createdStringPrompt.fileHashes);
+    
+    // Test with object prompt without files
+    const promptWithoutFiles = {
+        name: 'No Files Prompt',
+        prompt: 'Simple task'
+    };
+    
+    const createdPromptNoFiles = pathwayManager._createPromptObject(promptWithoutFiles, 'System prompt');
+    
+    t.is(createdPromptNoFiles.name, 'No Files Prompt');
+    t.falsy(createdPromptNoFiles.fileHashes);
+});

package/tests/unit/graphql_executeWorkspace_transformation.test.js

@@ -0,0 +1,244 @@
+/**
+ * Cortex Pathway Argument Transformation Tests
+ * 
+ * This test suite validates the argument transformation logic used when executing
+ * cortex pathways through the GraphQL executeWorkspace mutation. Specifically, it tests
+ * how the system transforms incoming pathway arguments (text, chatHistory, model) into
+ * the format expected by cortex pathways.
+ * 
+ * Key transformation behaviors tested:
+ * - Merging text parameters with existing chatHistory entries
+ * - Preserving multimodal content (images, etc.) in the correct order
+ * - Creating new user messages when no chatHistory exists
+ * - Handling model selection with fallback to default values
+ * - Ensuring content arrays maintain proper JSON-stringified structure
+ * 
+ * The transformation logic ensures that:
+ * 1. Text content is prepended to the last user message's content array
+ * 2. Existing multimodal content (e.g., images) is preserved
+ * 3. If no user message exists, a new one is created with the text
+ * 4. Model and systemPrompt are properly inherited from pathway configuration
+ * 
+ * These tests simulate the core transformation logic from executePathwayWithFallback
+ * without requiring full integration test setup, allowing for focused unit testing
+ * of the argument transformation behavior.
+ */
+
+import test from 'ava';
+
+// Test the transformation logic directly without mocking
+test('should format cortex pathway arguments correctly with existing chatHistory', (t) => {
+    // Mock the original prompt
+    const originalPrompt = {
+        name: 'summarize',
+        prompt: 'summarize this file',
+        cortexPathwayName: 'run_labeeb_agent'
+    };
+    
+    // Mock pathway data
+    const pathway = {
+        model: 'labeeb-agent',
+        systemPrompt: 'Test system prompt'
+    };
+    
+    // Mock incoming pathway args
+    const pathwayArgs = {
+        text: 'summarize the file',
+        chatHistory: [
+            {
+                role: 'user',
+                content: [
+                    '{"type":"image_url","url":"test-url","image_url":{"url":"test-url"},"gcs":"test-gcs","originalFilename":"test.jpg","hash":"test-hash"}'
+                ]
+            }
+        ]
+    };
+    
+    // Simulate the transformation logic from the executePathwayWithFallback function
+    const cortexArgs = {
+        model: pathway.model || pathwayArgs.model || "labeeb-agent",
+        chatHistory: [],
+        systemPrompt: pathway.systemPrompt
+    };
+    
+    // If we have existing chatHistory, use it as base
+    if (pathwayArgs.chatHistory && pathwayArgs.chatHistory.length > 0) {
+        cortexArgs.chatHistory = JSON.parse(JSON.stringify(pathwayArgs.chatHistory));
+    }
+    
+    // If we have text parameter, we need to add it to the chatHistory
+    if (pathwayArgs.text) {
+        // Find the last user message or create a new one
+        let lastUserMessage = null;
+        for (let i = cortexArgs.chatHistory.length - 1; i >= 0; i--) {
+            if (cortexArgs.chatHistory[i].role === 'user') {
+                lastUserMessage = cortexArgs.chatHistory[i];
+                break;
+            }
+        }
+        
+        if (lastUserMessage) {
+            // Ensure content is an array
+            if (!Array.isArray(lastUserMessage.content)) {
+                lastUserMessage.content = [JSON.stringify({
+                    type: "text",
+                    text: lastUserMessage.content || ""
+                })];
+            }
+            
+            // Add the text parameter as a text content item
+            const textFromPrompt = originalPrompt?.prompt || pathwayArgs.text;
+            lastUserMessage.content.unshift(JSON.stringify({
+                type: "text",
+                text: `${pathwayArgs.text}\n\n${textFromPrompt}`
+            }));
+        } else {
+            // Create new user message with text
+            const textFromPrompt = originalPrompt?.prompt || pathwayArgs.text;
+            cortexArgs.chatHistory.push({
+                role: 'user',
+                content: [JSON.stringify({
+                    type: "text",
+                    text: `${pathwayArgs.text}\n\n${textFromPrompt}`
+                })]
+            });
+        }
+    }
+    
+    // Verify the transformation
+    t.is(cortexArgs.model, 'labeeb-agent');
+    t.is(cortexArgs.systemPrompt, 'Test system prompt');
+    t.is(cortexArgs.chatHistory.length, 1);
+    
+    // Check that the user message has the correct structure
+    const userMessage = cortexArgs.chatHistory[0];
+    t.is(userMessage.role, 'user');
+    t.true(Array.isArray(userMessage.content));
+    t.is(userMessage.content.length, 2);
+    
+    // Check the text content was added first
+    const textContent = JSON.parse(userMessage.content[0]);
+    t.is(textContent.type, 'text');
+    t.is(textContent.text, 'summarize the file\n\nsummarize this file');
+    
+    // Check the image content is preserved second
+    const imageContent = JSON.parse(userMessage.content[1]);
+    t.is(imageContent.type, 'image_url');
+    t.is(imageContent.gcs, 'test-gcs');
+});
+
+test('should create new user message when no existing chatHistory', (t) => {
+    // Mock the original prompt
+    const originalPrompt = {
+        name: 'summarize',
+        prompt: 'summarize this file',
+        cortexPathwayName: 'run_labeeb_agent'
+    };
+    
+    // Mock pathway data
+    const pathway = {
+        model: 'labeeb-agent',
+        systemPrompt: 'Test system prompt'
+    };
+    
+    // Mock incoming pathway args with no chatHistory
+    const pathwayArgs = {
+        text: 'summarize the file'
+    };
+    
+    // Simulate the transformation logic from the executePathwayWithFallback function
+    const cortexArgs = {
+        model: pathway.model || pathwayArgs.model || "labeeb-agent",
+        chatHistory: [],
+        systemPrompt: pathway.systemPrompt
+    };
+    
+    // If we have existing chatHistory, use it as base
+    if (pathwayArgs.chatHistory && pathwayArgs.chatHistory.length > 0) {
+        cortexArgs.chatHistory = JSON.parse(JSON.stringify(pathwayArgs.chatHistory));
+    }
+    
+    // If we have text parameter, we need to add it to the chatHistory
+    if (pathwayArgs.text) {
+        // Find the last user message or create a new one
+        let lastUserMessage = null;
+        for (let i = cortexArgs.chatHistory.length - 1; i >= 0; i--) {
+            if (cortexArgs.chatHistory[i].role === 'user') {
+                lastUserMessage = cortexArgs.chatHistory[i];
+                break;
+            }
+        }
+        
+        if (lastUserMessage) {
+            // Ensure content is an array
+            if (!Array.isArray(lastUserMessage.content)) {
+                lastUserMessage.content = [JSON.stringify({
+                    type: "text",
+                    text: lastUserMessage.content || ""
+                })];
+            }
+            
+            // Add the text parameter as a text content item
+            const textFromPrompt = originalPrompt?.prompt || pathwayArgs.text;
+            lastUserMessage.content.unshift(JSON.stringify({
+                type: "text",
+                text: `${pathwayArgs.text}\n\n${textFromPrompt}`
+            }));
+        } else {
+            // Create new user message with text
+            const textFromPrompt = originalPrompt?.prompt || pathwayArgs.text;
+            cortexArgs.chatHistory.push({
+                role: 'user',
+                content: [JSON.stringify({
+                    type: "text",
+                    text: `${pathwayArgs.text}\n\n${textFromPrompt}`
+                })]
+            });
+        }
+    }
+    
+    // Verify the transformation
+    t.is(cortexArgs.model, 'labeeb-agent');
+    t.is(cortexArgs.systemPrompt, 'Test system prompt');
+    t.is(cortexArgs.chatHistory.length, 1);
+    
+    // Check that a new user message was created
+    const userMessage = cortexArgs.chatHistory[0];
+    t.is(userMessage.role, 'user');
+    t.true(Array.isArray(userMessage.content));
+    t.is(userMessage.content.length, 1);
+    
+    // Check the text content
+    const textContent = JSON.parse(userMessage.content[0]);
+    t.is(textContent.type, 'text');
+    t.is(textContent.text, 'summarize the file\n\nsummarize this file');
+});
+
+test('should use default model when pathway model is not specified', (t) => {
+    // Mock the original prompt
+    const originalPrompt = {
+        name: 'summarize',
+        prompt: 'summarize this file',
+        cortexPathwayName: 'run_labeeb_agent'
+    };
+    
+    // Mock pathway data without model
+    const pathway = {
+        systemPrompt: 'Test system prompt'
+    };
+    
+    // Mock incoming pathway args
+    const pathwayArgs = {
+        text: 'summarize the file'
+    };
+    
+    // Simulate the transformation logic
+    const cortexArgs = {
+        model: pathway.model || pathwayArgs.model || "labeeb-agent",
+        chatHistory: [],
+        systemPrompt: pathway.systemPrompt
+    };
+    
+    // Verify default model is used
+    t.is(cortexArgs.model, 'labeeb-agent');
+});

package/tests/unit/server/graphql.test.js

@@ -2,6 +2,9 @@ import test from 'ava';
 import sinon from 'sinon';
 import { getResolvers } from '../../../server/graphql.js';
 
+// Mock callPathway to avoid actual external calls
+const mockCallPathway = sinon.stub();
+
 // Mock logger to avoid actual logging during tests
 const mockLogger = {
     info: sinon.stub(),
@@ -17,7 +20,7 @@ const mockConfig = {
 
 test.beforeEach(t => {
     // Reset stubs before each test
-    sinon.restore();
+    mockCallPathway.resetHistory();
     mockLogger.info.resetHistory();
     mockLogger.debug.resetHistory();
     mockLogger.error.resetHistory();
@@ -168,3 +171,121 @@ test('executeWorkspace does not check format when promptNames not provided', asy
     t.false(mockPathwayManager.isLegacyPromptFormat.called);
     t.true(mockPathwayManager.getPathway.calledOnce);
 });
+
+test('executeWorkspace helper function DRY refactoring - structure verification', async t => {
+    // This test verifies that the DRY refactoring doesn't break existing functionality
+    // by testing that all three code paths (wildcard, specific prompts, default) 
+    // still work with fallback to legacy execution
+    
+    const mockRootResolver = sinon.stub().resolves({ result: 'legacy-result' });
+
+    // Test wildcard case with legacy fallback
+    const mockPathwayManager = {
+        getLatestPathways: sinon.stub().resolves({
+            'test-user': {
+                'test-pathway': {
+                    prompt: [
+                        { name: 'prompt1' }, // No cortexPathwayName - will fallback
+                        { name: 'prompt2' }  // No cortexPathwayName - will fallback
+                    ],
+                    systemPrompt: 'Test system prompt'
+                }
+            }
+        }),
+        isLegacyPromptFormat: sinon.stub().returns(false),
+        getPathways: sinon.stub().resolves([
+            {
+                name: 'prompt1',
+                systemPrompt: 'System prompt 1',
+                prompt: [{ messages: ['message1'] }],
+                fileHashes: [],
+                rootResolver: mockRootResolver
+            },
+            {
+                name: 'prompt2',
+                systemPrompt: 'System prompt 2', 
+                prompt: [{ messages: ['message2'] }],
+                fileHashes: [],
+                rootResolver: mockRootResolver
+            }
+        ]),
+        getResolvers: sinon.stub().returns({ Mutation: {} })
+    };
+
+    const resolvers = getResolvers(mockConfig, {}, mockPathwayManager);
+    const executeWorkspaceResolver = resolvers.Query.executeWorkspace;
+
+    const mockContextValue = { config: mockConfig };
+    const mockInfo = {};
+
+    const args = {
+        userId: 'test-user',
+        pathwayName: 'test-pathway',
+        promptNames: ['*'], // Wildcard to execute all
+        text: 'test input'
+    };
+
+    const result = await executeWorkspaceResolver(null, args, mockContextValue, mockInfo);
+
+    // Verify that legacy resolvers were called (indicating the DRY helper function worked)
+    t.is(mockRootResolver.callCount, 2); // Called twice for both prompts
+    
+    // Verify result structure matches expected format
+    t.truthy(result);
+    t.truthy(result.result);
+    t.true(result.debug.includes('Executed 2 prompts in parallel'));
+    
+    // Parse the result to verify both prompts were executed
+    const parsedResult = JSON.parse(result.result);
+    t.is(parsedResult.length, 2);
+    t.is(parsedResult[0].promptName, 'prompt1');
+    t.is(parsedResult[1].promptName, 'prompt2');
+});
+
+test('executeWorkspace helper function DRY refactoring - default case structure', async t => {
+    // Test that the default case still works with the DRY helper function
+    
+    const mockRootResolver = sinon.stub().resolves({ result: 'default-legacy-result' });
+
+    const mockPathwayManager = {
+        getLatestPathways: sinon.stub().resolves({
+            'test-user': {
+                'test-pathway': {
+                    prompt: [
+                        { name: 'default-prompt' } // No cortexPathwayName
+                    ],
+                    systemPrompt: 'Test system prompt'
+                }
+            }
+        }),
+        getPathway: sinon.stub().resolves({
+            prompt: [{ name: 'default-prompt' }], // No cortexPathwayName
+            systemPrompt: 'Test system prompt',
+            fileHashes: [],
+            rootResolver: mockRootResolver
+        }),
+        getResolvers: sinon.stub().returns({ Mutation: {} })
+    };
+
+    const resolvers = getResolvers(mockConfig, {}, mockPathwayManager);
+    const executeWorkspaceResolver = resolvers.Query.executeWorkspace;
+
+    const mockContextValue = { config: mockConfig };
+    const mockInfo = {};
+
+    const args = {
+        userId: 'test-user',
+        pathwayName: 'test-pathway',
+        text: 'test input'
+        // No promptNames provided - uses default case
+    };
+
+    const result = await executeWorkspaceResolver(null, args, mockContextValue, mockInfo);
+
+    // Verify that legacy resolver was called (indicating DRY helper function worked for default case)
+    t.is(mockRootResolver.callCount, 1);
+    
+    // Verify result structure
+    t.truthy(result);
+    t.is(result.result, 'default-legacy-result');
+});