@aj-archipelago/cortex 1.4.6 → 1.4.7

package/pathways/system/entity/tools/sys_tool_analyzefile.js

@@ -0,0 +1,171 @@
+// sys_tool_analyzefile.js
+// Entity tool that analyzes one or more files and answers questions about them
+
+import { Prompt } from '../../../../server/prompt.js';
+import { generateFileMessageContent, injectFileIntoChatHistory } from '../../../../lib/fileUtils.js';
+
+export default {
+    prompt:
+        [
+            new Prompt({ messages: [
+                {"role": "system", "content": `You are the part of an AI entity named {{aiName}} that can view, hear, and understand files of all sorts (images, videos, audio, pdfs, text, etc.) - you provide the capability to view and analyze files that the user provides.\nThe user has provided you with one or more files in this conversation - you should consider them for context when you respond.\nIf you don't see any files, something has gone wrong in the upload and you should inform the user and have them try again.\n{{renderTemplate AI_DATETIME}}`},
+                "{{chatHistory}}",
+            ]}),
+        ],
+    inputParameters: {
+        chatHistory: [{role: '', content: []}],
+        contextId: ``,
+        contextKey: ``,
+        aiName: "Jarvis",
+        language: "English",
+    },
+    max_tokens: 8192,
+    model: 'gemini-flash-20-vision',
+    useInputChunking: false,
+    enableDuplicateRequests: false,
+    timeout: 600,
+    geminiSafetySettings: [{category: 'HARM_CATEGORY_DANGEROUS_CONTENT', threshold: 'BLOCK_ONLY_HIGH'},
+        {category: 'HARM_CATEGORY_SEXUALLY_EXPLICIT', threshold: 'BLOCK_ONLY_HIGH'},
+        {category: 'HARM_CATEGORY_HARASSMENT', threshold: 'BLOCK_ONLY_HIGH'},
+        {category: 'HARM_CATEGORY_HATE_SPEECH', threshold: 'BLOCK_ONLY_HIGH'}],
+    toolDefinition: [{
+        type: "function",
+        icon: "📄",
+        function: {
+            name: "AnalyzePDF",
+            description: "Use specifically for reading, analyzing, and answering questions about PDF file content. Do not use this tool for analyzing and answering questions about other file types.",
+            parameters: {
+                type: "object",
+                properties: {
+                    detailedInstructions: {
+                        type: "string",
+                        description: "Detailed instructions about what you need the tool to do - questions you need answered about the files, etc."
+                    },
+                    file: {
+                        type: "string",
+                        description: "Optional: The file to analyze (from ListFileCollection or SearchFileCollection): can be the hash, the filename, the URL, or the GCS URL. You can find available files in the availableFiles section."
+                    },
+                    userMessage: {
+                        type: "string",
+                        description: "A user-friendly message that describes what you're doing with this tool"
+                    }
+                },
+                required: ["detailedInstructions", "userMessage"]
+            }
+        }
+    },
+    {
+        type: "function",
+        icon: "📝",
+        function: {
+            name: "AnalyzeText",
+            description: "Use specifically for reading, analyzing, and answering questions about text files (including csv, json, html, etc.).",
+            parameters: {
+                type: "object",
+                properties: {
+                    detailedInstructions: {
+                        type: "string",
+                        description: "Detailed instructions about what you need the tool to do - questions you need answered about the files, etc."
+                        },
+                    userMessage: {
+                        type: "string",
+                        description: "A user-friendly message that describes what you're doing with this tool"
+                        }
+                },
+                required: ["detailedInstructions", "userMessage"]
+            }
+        }
+    },
+    {
+        type: "function",
+        icon: "📝",
+        function: {
+            name: "AnalyzeMarkdown",
+            description: "Use specifically for reading, analyzing, and answering questions about markdown files.",
+            parameters: {
+                type: "object",
+                properties: {
+                    detailedInstructions: {
+                        type: "string",
+                        description: "Detailed instructions about what you need the tool to do - questions you need answered about the files, etc."
+                        },
+                    userMessage: {
+                        type: "string",
+                        description: "A user-friendly message that describes what you're doing with this tool"
+                        }
+                },
+                required: ["detailedInstructions", "userMessage"]
+            }
+        }
+    },   
+    {
+        type: "function",
+        icon: "🖼️",
+        function: {
+            name: "AnalyzeImage",
+            description: "Use specifically for reading, analyzing, and answering questions about image files (jpg, gif, bmp, png, etc). This cannot be used for creating or transforming images.",
+            parameters: {
+                type: "object",
+                properties: {
+                    detailedInstructions: {
+                        type: "string",
+                        description: "Detailed instructions about what you need the tool to do - questions you need answered about the files, etc."
+                    },
+                    file: {
+                        type: "string",
+                        description: "Optional: The file to analyze (from ListFileCollection or SearchFileCollection): can be the hash, the filename, the URL, or the GCS URL. You can find available files in the availableFiles section."
+                    },
+                    userMessage: {
+                        type: "string",
+                        description: "A user-friendly message that describes what you're doing with this tool"
+                    }
+                },
+                required: ["detailedInstructions", "userMessage"]
+            }
+        }
+    },
+    {
+        type: "function",
+        icon: "🎥",
+        function: {
+            name: "AnalyzeVideo",
+            description: "Use specifically for reading, analyzing, and answering questions about video or audio file content. You MUST use this tool to look at video or audio files.",
+            parameters: {
+                type: "object",
+                properties: {
+                    detailedInstructions: {
+                        type: "string",
+                        description: "Detailed instructions about what you need the tool to do - questions you need answered about the files, etc."
+                    },
+                    file: {
+                        type: "string",
+                        description: "Optional: The file to analyze (from ListFileCollection or SearchFileCollection): can be the hash, the filename, the URL, or the GCS URL. You can find available files in the availableFiles section."
+                    },
+                    userMessage: {
+                        type: "string",
+                        description: "A user-friendly message that describes what you're doing with this tool"
+                    }
+                },
+                required: ["detailedInstructions", "userMessage"]
+            }
+        }
+    }],
+    
+    executePathway: async ({args, runAllPrompts, resolver}) => {
+        // Generate file message content and inject file if provided
+        if (args.file) {
+            const fileContent = await generateFileMessageContent(args.file, args.contextId, args.contextKey);
+            if (!fileContent) {
+                throw new Error(`File not found: "${args.file}". Use ListFileCollection or SearchFileCollection to find available files.`);
+            }
+            args.chatHistory = injectFileIntoChatHistory(args.chatHistory, fileContent);
+        }
+
+        if (args.detailedInstructions) {
+            args.chatHistory.push({role: "user", content: args.detailedInstructions});
+        }
+        const result = await runAllPrompts({ ...args });
+        resolver.tool = JSON.stringify({ toolUsed: "vision" });
+        return result;
+    }
+}

package/pathways/system/entity/tools/sys_tool_codingagent.js

@@ -3,6 +3,7 @@
 
 import { QueueServiceClient } from '@azure/storage-queue';
 import logger from '../../../../lib/logger.js';
+import { resolveFileParameter } from '../../../../lib/fileUtils.js';
 
 const connectionString = process.env.AZURE_STORAGE_CONNECTION_STRING;
 let queueClient;
@@ -58,7 +59,7 @@ export default {
                     },
                     inputFiles: {
                         type: "string",
-                        description: "A list of input files that the coding agent must use to complete the task. Each file should be the fully-qualified URL to the file. Omit this parameter if no input files are needed."
+                        description: "A list of input files (from Available Files section or ListFileCollection or SearchFileCollection) that the coding agent must use to complete the task. Each file should be the hash or filename. Omit this parameter if no input files are needed."
                     },
                     userMessage: {
                         type: "string",
@@ -76,12 +77,45 @@ export default {
     
     executePathway: async ({args, resolver}) => {
         try {
-            const { codingTask, userMessage, inputFiles, codingTaskKeywords } = args;
-            const { contextId } = args;
+            const { codingTask, userMessage, inputFiles, codingTaskKeywords, contextId, contextKey } = args;
 
             let taskSuffix = "";
             if (inputFiles) {
-                taskSuffix = `You must use the following files as input to complete the task: ${inputFiles}.`
+                if (!contextId) {
+                    throw new Error("contextId is required when using the 'inputFiles' parameter. Use ListFileCollection or SearchFileCollection to find available files.");
+                }
+                
+                // Resolve file parameters to URLs
+                // inputFiles can be a comma-separated, newline-separated, or space-separated list
+                const fileReferences = inputFiles
+                    .split(/[,\n\r]+/)
+                    .map(ref => ref.trim())
+                    .filter(ref => ref.length > 0);
+                
+                const resolvedUrls = [];
+                const failedFiles = [];
+                
+                for (const fileRef of fileReferences) {
+                    // Try to resolve each file reference
+                    const resolvedUrl = await resolveFileParameter(fileRef, contextId, contextKey);
+                    if (resolvedUrl) {
+                        resolvedUrls.push(resolvedUrl);
+                    } else {
+                        failedFiles.push(fileRef);
+                    }
+                }
+                
+                // Fail early if any files couldn't be resolved
+                if (failedFiles.length > 0) {
+                    const fileList = failedFiles.length === 1 
+                        ? `"${failedFiles[0]}"` 
+                        : failedFiles.map(f => `"${f}"`).join(', ');
+                    throw new Error(`File(s) not found: ${fileList}. Use ListFileCollection or SearchFileCollection to find available files.`);
+                }
+                
+                if (resolvedUrls.length > 0) {
+                    taskSuffix = `You must use the following files as input to complete the task: ${resolvedUrls.join(', ')}.`
+                }
             }
 
 

package/pathways/system/entity/tools/sys_tool_editfile.js

@@ -0,0 +1,403 @@
+// sys_tool_editfile.js
+// Entity tool that modifies existing files by replacing line ranges or exact string matches
+import logger from '../../../../lib/logger.js';
+import { axios } from '../../../../lib/requestExecutor.js';
+import { uploadFileToCloud, findFileInCollection, loadFileCollection, saveFileCollection, getMimeTypeFromFilename, resolveFileParameter, deleteFileByHash, modifyFileCollectionWithLock } from '../../../../lib/fileUtils.js';
+
+export default {
+    prompt: [],
+    timeout: 120,
+    toolDefinition: [
+        { 
+            type: "function",
+            icon: "✏️",
+            function: {
+                name: "EditFileByLine",
+                description: "Modify an existing file by replacing a range of lines. Use this for line-based edits where you know the exact line numbers to replace. The file must exist in your file collection and must be a text-type file (text, markdown, html, csv, etc.). After modification, the file is re-uploaded and the collection entry is updated.",
+                parameters: {
+                    type: "object",
+                    properties: {
+                        file: {
+                            type: "string",
+                            description: "The file to modify: can be the file ID, filename, URL, or hash from your file collection. You can find available files in the Available Files section or ListFileCollection or SearchFileCollection."
+                        },
+                        startLine: {
+                            type: "number",
+                            description: "Starting line number (1-indexed) to replace. The line range is inclusive (both startLine and endLine are replaced)."
+                        },
+                        endLine: {
+                            type: "number",
+                            description: "Ending line number (1-indexed) to replace. Must be >= startLine. The line range is inclusive (both startLine and endLine are replaced)."
+                        },
+                        content: {
+                            type: "string",
+                            description: "New content to replace the specified line range. This will replace lines startLine through endLine (inclusive)."
+                        },
+                        userMessage: {
+                            type: "string",
+                            description: "A user-friendly message that describes what you're doing with this tool"
+                        }
+                    },
+                    required: ["file", "startLine", "endLine", "content", "userMessage"]
+                }
+            }
+        },
+        {
+            type: "function",
+            icon: "🔍",
+            function: {
+                name: "EditFileBySearchAndReplace",
+                description: "Search and replace exact string matches in a file. Use this when you know the exact text to find and replace. The file must exist in your file collection and must be a text-type file (text, markdown, html, csv, etc.). After modification, the old file version is deleted from cloud storage and the new version is uploaded. The collection entry is updated with the new URL and hash.",
+                parameters: {
+                    type: "object",
+                    properties: {
+                        file: {
+                            type: "string",
+                            description: "The file to modify: can be the file ID, filename, URL, or hash from your file collection. You can find available files in the Available Files section or ListFileCollection or SearchFileCollection."
+                        },
+                        oldString: {
+                            type: "string",
+                            description: "Exact string to replace. Must match the exact text in the file (including whitespace and newlines). The search is case-sensitive and must match exactly."
+                        },
+                        newString: {
+                            type: "string",
+                            description: "New content to replace oldString with."
+                        },
+                        replaceAll: {
+                            type: "boolean",
+                            description: "Optional: If true, replace all occurrences of oldString. Default: false (replace only first occurrence)."
+                        },
+                        userMessage: {
+                            type: "string",
+                            description: "A user-friendly message that describes what you're doing with this tool"
+                        }
+                    },
+                    required: ["file", "oldString", "newString", "userMessage"]
+                }
+            }
+        }
+    ],
+
+    executePathway: async ({args, runAllPrompts, resolver}) => {
+        const { file, startLine, endLine, content, oldString, newString, replaceAll = false, contextId, contextKey } = args;
+        
+        // Determine which tool was called based on parameters
+        const isSearchReplace = oldString !== undefined && newString !== undefined;
+        const isEditByLine = startLine !== undefined && endLine !== undefined && content !== undefined;
+        const toolName = isSearchReplace ? "EditFileBySearchAndReplace" : "EditFileByLine";
+        
+        // Validate basic inputs
+        if (!file || typeof file !== 'string') {
+            const errorResult = {
+                success: false,
+                error: "file parameter is required and must be a string"
+            };
+            resolver.tool = JSON.stringify({ toolUsed: toolName });
+            return JSON.stringify(errorResult);
+        }
+
+        if (!contextId) {
+            const errorResult = {
+                success: false,
+                error: "contextId is required for file modification"
+            };
+            resolver.tool = JSON.stringify({ toolUsed: toolName });
+            return JSON.stringify(errorResult);
+        }
+
+        // Validate that we have the right parameters for the tool being used
+        if (!isSearchReplace && !isEditByLine) {
+            const errorResult = {
+                success: false,
+                error: "Either use EditFileByLine (with startLine/endLine/content) or EditFileBySearchAndReplace (with oldString/newString)"
+            };
+            resolver.tool = JSON.stringify({ toolUsed: toolName });
+            return JSON.stringify(errorResult);
+        }
+
+        // Validate EditFileByLine parameters
+        if (isEditByLine) {
+            if (typeof startLine !== 'number' || startLine < 1) {
+                const errorResult = {
+                    success: false,
+                    error: "startLine must be a positive integer (1-indexed)"
+                };
+                resolver.tool = JSON.stringify({ toolUsed: "EditFileByLine" });
+                return JSON.stringify(errorResult);
+            }
+
+            if (typeof endLine !== 'number' || endLine < 1) {
+                const errorResult = {
+                    success: false,
+                    error: "endLine must be a positive integer (1-indexed)"
+                };
+                resolver.tool = JSON.stringify({ toolUsed: "EditFileByLine" });
+                return JSON.stringify(errorResult);
+            }
+
+            if (endLine < startLine) {
+                const errorResult = {
+                    success: false,
+                    error: "endLine must be >= startLine"
+                };
+                resolver.tool = JSON.stringify({ toolUsed: "EditFileByLine" });
+                return JSON.stringify(errorResult);
+            }
+
+            if (typeof content !== 'string') {
+                const errorResult = {
+                    success: false,
+                    error: "content is required and must be a string"
+                };
+                resolver.tool = JSON.stringify({ toolUsed: "EditFileByLine" });
+                return JSON.stringify(errorResult);
+            }
+        }
+
+        // Validate EditFileBySearchAndReplace parameters
+        if (isSearchReplace) {
+            if (typeof oldString !== 'string') {
+                const errorResult = {
+                    success: false,
+                    error: "oldString is required and must be a string"
+                };
+                resolver.tool = JSON.stringify({ toolUsed: "EditFileBySearchAndReplace" });
+                return JSON.stringify(errorResult);
+            }
+
+            if (typeof newString !== 'string') {
+                const errorResult = {
+                    success: false,
+                    error: "newString is required and must be a string"
+                };
+                resolver.tool = JSON.stringify({ toolUsed: "EditFileBySearchAndReplace" });
+                return JSON.stringify(errorResult);
+            }
+        }
+
+        try {
+            // Resolve the file parameter to a URL using the common utility
+            const fileUrl = await resolveFileParameter(file, contextId, contextKey);
+            
+            if (!fileUrl) {
+                const errorResult = {
+                    success: false,
+                    error: `File not found: "${file}". Use ListFileCollection or SearchFileCollection to find available files.`
+                };
+                resolver.tool = JSON.stringify({ toolUsed: toolName });
+                return JSON.stringify(errorResult);
+            }
+
+            // Find the file in the collection to get metadata (for updating later)
+            // We'll load it again inside the lock, but need to verify it exists first
+            const collection = await loadFileCollection(contextId, contextKey, true);
+            const foundFile = findFileInCollection(file, collection);
+
+            if (!foundFile) {
+                const errorResult = {
+                    success: false,
+                    error: `File not found in collection: "${file}"`
+                };
+                resolver.tool = JSON.stringify({ toolUsed: toolName });
+                return JSON.stringify(errorResult);
+            }
+            
+            // Store the file ID for updating inside the lock
+            const fileIdToUpdate = foundFile.id;
+
+            // Download the current file content
+            logger.info(`Downloading file for modification: ${fileUrl}`);
+            const downloadResponse = await axios.get(fileUrl, {
+                responseType: 'arraybuffer',
+                timeout: 60000,
+                validateStatus: (status) => status >= 200 && status < 400
+            });
+
+            if (downloadResponse.status !== 200 || !downloadResponse.data) {
+                throw new Error(`Failed to download file: ${downloadResponse.status}`);
+            }
+
+            // Explicitly decode as UTF-8 to prevent mojibake (encoding corruption)
+            const originalContent = Buffer.from(downloadResponse.data).toString('utf8');
+            let modifiedContent;
+            let modificationInfo = {};
+
+            if (isEditByLine) {
+                // Line-based replacement mode
+                const allLines = originalContent.split(/\r?\n/);
+                const totalLines = allLines.length;
+
+                // Validate line range
+                if (startLine > totalLines) {
+                    const errorResult = {
+                        success: false,
+                        error: `startLine (${startLine}) exceeds file length (${totalLines} lines)`
+                    };
+                    resolver.tool = JSON.stringify({ toolUsed: "EditFileByLine" });
+                    return JSON.stringify(errorResult);
+                }
+
+                // Perform the line replacement
+                const startIndex = startLine - 1;
+                const endIndex = Math.min(endLine, totalLines);
+                
+                // Split the replacement content into lines
+                const replacementLines = content.split(/\r?\n/);
+                
+                // Build the modified content
+                const beforeLines = allLines.slice(0, startIndex);
+                const afterLines = allLines.slice(endIndex);
+                const modifiedLines = [...beforeLines, ...replacementLines, ...afterLines];
+                modifiedContent = modifiedLines.join('\n');
+
+                modificationInfo = {
+                    mode: 'line-based',
+                    originalLines: totalLines,
+                    modifiedLines: modifiedLines.length,
+                    replacedLines: endLine - startLine + 1,
+                    insertedLines: replacementLines.length,
+                    startLine: startLine,
+                    endLine: endLine
+                };
+            } else if (isSearchReplace) {
+                // Search and replace mode
+                if (!originalContent.includes(oldString)) {
+                    const errorResult = {
+                        success: false,
+                        error: `oldString not found in file. The exact string must match (including whitespace and newlines).`
+                    };
+                    resolver.tool = JSON.stringify({ toolUsed: "EditFileBySearchAndReplace" });
+                    return JSON.stringify(errorResult);
+                }
+
+                // Count occurrences
+                const occurrences = (originalContent.match(new RegExp(oldString.replace(/[.*+?^${}()|[\]\\]/g, '\\$&'), 'g')) || []).length;
+                
+                if (replaceAll) {
+                    modifiedContent = originalContent.split(oldString).join(newString);
+                    modificationInfo = {
+                        mode: 'string-based',
+                        replaceAll: true,
+                        occurrencesReplaced: occurrences
+                    };
+                } else {
+                    // Replace only first occurrence
+                    modifiedContent = originalContent.replace(oldString, newString);
+                    modificationInfo = {
+                        mode: 'string-based',
+                        replaceAll: false,
+                        occurrencesReplaced: 1,
+                        totalOccurrences: occurrences
+                    };
+                }
+            }
+
+            // Determine MIME type from filename using utility function
+            const filename = foundFile.filename || 'modified.txt';
+            let mimeType = getMimeTypeFromFilename(filename, 'text/plain');
+            
+            // Add charset=utf-8 for text-based MIME types
+            if (mimeType.startsWith('text/') || mimeType === 'application/json' || 
+                mimeType === 'application/javascript' || mimeType === 'application/typescript' ||
+                mimeType === 'application/xml') {
+                mimeType = `${mimeType}; charset=utf-8`;
+            }
+
+            // Delete the old file version before uploading the new one
+            const oldHash = foundFile.hash;
+            if (oldHash) {
+                logger.info(`Deleting old file version with hash ${oldHash} before uploading new version`);
+                const deleted = await deleteFileByHash(oldHash, resolver);
+                if (deleted) {
+                    logger.info(`Successfully deleted old file version`);
+                } else {
+                    logger.info(`Old file version not found or already deleted (hash: ${oldHash})`);
+                }
+            } else {
+                logger.info(`No hash found for old file, skipping deletion`);
+            }
+
+            // Upload the modified file
+            const fileBuffer = Buffer.from(modifiedContent, 'utf8');
+            const uploadResult = await uploadFileToCloud(
+                fileBuffer,
+                mimeType,
+                filename,
+                resolver
+            );
+
+            if (!uploadResult || !uploadResult.url) {
+                throw new Error('Failed to upload modified file to cloud storage');
+            }
+
+            // Update the file collection entry with new URL and hash using optimistic locking
+            const updatedCollection = await modifyFileCollectionWithLock(contextId, contextKey, (collection) => {
+                const fileToUpdate = collection.find(f => f.id === fileIdToUpdate);
+                if (!fileToUpdate) {
+                    throw new Error(`File with ID "${fileIdToUpdate}" not found in collection during update`);
+                }
+                
+                fileToUpdate.url = uploadResult.url;
+                if (uploadResult.gcs) {
+                    fileToUpdate.gcs = uploadResult.gcs;
+                }
+                if (uploadResult.hash) {
+                    fileToUpdate.hash = uploadResult.hash;
+                }
+                fileToUpdate.lastAccessed = new Date().toISOString();
+                
+                return collection;
+            });
+            
+            // Get the updated file info for the result
+            const updatedFile = updatedCollection.find(f => f.id === fileIdToUpdate);
+
+            // Build result message
+            let message;
+            if (isEditByLine) {
+                message = `File "${filename}" modified successfully. Replaced lines ${startLine}-${endLine} (${endLine - startLine + 1} lines) with ${modificationInfo.insertedLines} line(s).`;
+            } else if (isSearchReplace) {
+                if (replaceAll) {
+                    message = `File "${filename}" modified successfully. Replaced all ${modificationInfo.occurrencesReplaced} occurrence(s) of the specified string.`;
+                } else {
+                    message = `File "${filename}" modified successfully. Replaced first occurrence of the specified string${modificationInfo.totalOccurrences > 1 ? ` (${modificationInfo.totalOccurrences} total occurrences found)` : ''}.`;
+                }
+            }
+
+            const result = {
+                success: true,
+                filename: filename,
+                fileId: updatedFile.id,
+                url: uploadResult.url,
+                gcs: uploadResult.gcs || null,
+                hash: uploadResult.hash || null,
+                ...modificationInfo,
+                message: message
+            };
+
+            resolver.tool = JSON.stringify({ toolUsed: toolName });
+            return JSON.stringify(result);
+
+        } catch (error) {
+            let errorMsg;
+            if (error?.message) {
+                errorMsg = error.message;
+            } else if (error?.errors && Array.isArray(error.errors)) {
+                // Handle AggregateError
+                errorMsg = error.errors.map(e => e?.message || String(e)).join('; ');
+            } else {
+                errorMsg = String(error);
+            }
+            logger.error(`Error modifying file: ${errorMsg}`);
+            
+            const errorResult = {
+                success: false,
+                error: errorMsg
+            };
+
+            resolver.tool = JSON.stringify({ toolUsed: toolName });
+            return JSON.stringify(errorResult);
+        }
+    }
+};
+