protoagent 0.0.1

package/dist/tools/search-files.js

@@ -0,0 +1,177 @@
+import fs from 'fs/promises';
+import path from 'path';
+// Current working directory for file operations
+const workingDirectory = process.cwd();
+// Security utilities
+function normalizePath(p) {
+    return path.normalize(p);
+}
+async function validatePath(requestedPath) {
+    const absolute = path.isAbsolute(requestedPath)
+        ? path.resolve(requestedPath)
+        : path.resolve(workingDirectory, requestedPath);
+    const normalizedRequested = normalizePath(absolute);
+    // Check if path is within working directory
+    if (!normalizedRequested.startsWith(workingDirectory)) {
+        throw new Error(`Access denied - path outside working directory: ${absolute}`);
+    }
+    // Handle symlinks by checking their real path
+    try {
+        const realPath = await fs.realpath(absolute);
+        const normalizedReal = normalizePath(realPath);
+        if (!normalizedReal.startsWith(workingDirectory)) {
+            throw new Error(`Access denied - symlink target outside working directory: ${realPath}`);
+        }
+        return realPath;
+    }
+    catch (error) {
+        // For new files that don't exist yet, verify parent directory
+        if (error.code === 'ENOENT') {
+            const parentDir = path.dirname(absolute);
+            try {
+                const realParentPath = await fs.realpath(parentDir);
+                const normalizedParent = normalizePath(realParentPath);
+                if (!normalizedParent.startsWith(workingDirectory)) {
+                    throw new Error(`Access denied - parent directory outside working directory: ${realParentPath}`);
+                }
+                return absolute;
+            }
+            catch {
+                throw new Error(`Parent directory does not exist: ${parentDir}`);
+            }
+        }
+        throw error;
+    }
+}
+// Search utility function
+async function searchInFile(filePath, searchTerm, caseSensitive = false) {
+    try {
+        const content = await fs.readFile(filePath, 'utf-8');
+        const lines = content.split('\n');
+        const matchingLines = [];
+        let totalMatches = 0;
+        const searchPattern = caseSensitive ? searchTerm : searchTerm.toLowerCase();
+        lines.forEach((line, index) => {
+            const searchLine = caseSensitive ? line : line.toLowerCase();
+            if (searchLine.includes(searchPattern)) {
+                totalMatches++;
+                matchingLines.push(`${index + 1}: ${line}`);
+            }
+        });
+        return { matches: totalMatches, lines: matchingLines };
+    }
+    catch (error) {
+        return { matches: 0, lines: [] };
+    }
+}
+async function searchInDirectory(dirPath, searchTerm, caseSensitive = false, fileExtensions = []) {
+    const validPath = await validatePath(dirPath);
+    const results = [];
+    async function searchRecursive(currentPath, depth = 0) {
+        if (depth > 10)
+            return; // Prevent infinite recursion
+        try {
+            const entries = await fs.readdir(currentPath, { withFileTypes: true });
+            for (const entry of entries) {
+                const fullPath = path.join(currentPath, entry.name);
+                // Skip common directories that should be ignored
+                if (entry.isDirectory() && ['node_modules', '.git', '.DS_Store', 'dist', 'build'].includes(entry.name)) {
+                    continue;
+                }
+                if (entry.isDirectory()) {
+                    await searchRecursive(fullPath, depth + 1);
+                }
+                else if (entry.isFile()) {
+                    // Check file extension filter
+                    if (fileExtensions.length > 0) {
+                        const ext = path.extname(entry.name).toLowerCase();
+                        if (!fileExtensions.includes(ext)) {
+                            continue;
+                        }
+                    }
+                    try {
+                        const searchResult = await searchInFile(fullPath, searchTerm, caseSensitive);
+                        if (searchResult.matches > 0) {
+                            const relativePath = path.relative(workingDirectory, fullPath);
+                            results.push(`\n📁 ${relativePath} (${searchResult.matches} matches):`);
+                            results.push(...searchResult.lines.map(line => `  ${line}`));
+                        }
+                    }
+                    catch (error) {
+                        // Skip files we can't read
+                    }
+                }
+            }
+        }
+        catch (error) {
+            // Skip directories we can't read
+        }
+    }
+    await searchRecursive(validPath);
+    if (results.length === 0) {
+        return `No matches found for "${searchTerm}" in ${dirPath}`;
+    }
+    return results.join('\n');
+}
+export async function searchFiles(searchTerm, dirPath = '.', caseSensitive = false, fileExtensions = []) {
+    try {
+        if (!searchTerm.trim()) {
+            throw new Error('Search term cannot be empty');
+        }
+        const validPath = await validatePath(dirPath);
+        // Check if path exists and is a directory
+        const stats = await fs.stat(validPath);
+        if (!stats.isDirectory()) {
+            throw new Error('Search path must be a directory');
+        }
+        const results = await searchInDirectory(validPath, searchTerm, caseSensitive, fileExtensions);
+        const searchInfo = [
+            `🔍 Searching for: "${searchTerm}"`,
+            `📂 In directory: ${path.relative(workingDirectory, validPath) || '.'}`,
+            `📝 Case sensitive: ${caseSensitive ? 'Yes' : 'No'}`,
+            fileExtensions.length > 0 ? `🎯 File types: ${fileExtensions.join(', ')}` : '🎯 All file types',
+            '',
+        ].join('\n');
+        return searchInfo + results;
+    }
+    catch (error) {
+        if (error instanceof Error) {
+            throw new Error(`Failed to search files: ${error.message}`);
+        }
+        throw new Error('Failed to search files: Unknown error');
+    }
+}
+// Tool definition
+export const searchFilesTool = {
+    type: 'function',
+    function: {
+        name: 'search_files',
+        description: 'Search for a text string within files in a directory. Supports case sensitivity and file type filtering. Returns the list of files and matching lines. Use this to find specific code, configuration settings, or documentation within your project files.',
+        parameters: {
+            type: 'object',
+            properties: {
+                search_term: {
+                    type: 'string',
+                    description: 'The text string to search for within files.'
+                },
+                directory_path: {
+                    type: 'string',
+                    description: 'The directory to search within, relative to the current working directory. Use "." for the current directory.'
+                },
+                case_sensitive: {
+                    type: 'boolean',
+                    description: 'Whether the search should be case sensitive.'
+                },
+                file_extensions: {
+                    type: 'array',
+                    items: {
+                        type: 'string',
+                        description: 'File extension to include in the search (e.g., "js", "txt"). Leave empty to search all file types.'
+                    },
+                    description: 'List of file extensions to include in the search.'
+                }
+            },
+            required: ['search_term', 'directory_path']
+        }
+    }
+};

package/dist/tools/search-operations.js

@@ -0,0 +1,179 @@
+import fs from 'fs/promises';
+import path from 'path';
+// Current working directory for file operations
+const workingDirectory = process.cwd();
+// Security utilities
+function normalizePath(p) {
+    return path.normalize(p);
+}
+async function validatePath(requestedPath) {
+    const absolute = path.isAbsolute(requestedPath)
+        ? path.resolve(requestedPath)
+        : path.resolve(workingDirectory, requestedPath);
+    const normalizedRequested = normalizePath(absolute);
+    // Check if path is within working directory
+    if (!normalizedRequested.startsWith(workingDirectory)) {
+        throw new Error(`Access denied - path outside working directory: ${absolute}`);
+    }
+    // Handle symlinks by checking their real path
+    try {
+        const realPath = await fs.realpath(absolute);
+        const normalizedReal = normalizePath(realPath);
+        if (!normalizedReal.startsWith(workingDirectory)) {
+            throw new Error(`Access denied - symlink target outside working directory: ${realPath}`);
+        }
+        return realPath;
+    }
+    catch (error) {
+        // For new files that don't exist yet, verify parent directory
+        if (error.code === 'ENOENT') {
+            const parentDir = path.dirname(absolute);
+            try {
+                const realParentPath = await fs.realpath(parentDir);
+                const normalizedParent = normalizePath(realParentPath);
+                if (!normalizedParent.startsWith(workingDirectory)) {
+                    throw new Error(`Access denied - parent directory outside working directory: ${realParentPath}`);
+                }
+                return absolute;
+            }
+            catch {
+                throw new Error(`Parent directory does not exist: ${parentDir}`);
+            }
+        }
+        throw error;
+    }
+}
+// Search utility function
+async function searchInFile(filePath, searchTerm, caseSensitive = false) {
+    try {
+        const content = await fs.readFile(filePath, 'utf-8');
+        const lines = content.split('\n');
+        const matchingLines = [];
+        let totalMatches = 0;
+        const searchPattern = caseSensitive ? searchTerm : searchTerm.toLowerCase();
+        lines.forEach((line, index) => {
+            const searchLine = caseSensitive ? line : line.toLowerCase();
+            if (searchLine.includes(searchPattern)) {
+                totalMatches++;
+                matchingLines.push(`${index + 1}: ${line}`);
+            }
+        });
+        return { matches: totalMatches, lines: matchingLines };
+    }
+    catch (error) {
+        return { matches: 0, lines: [] };
+    }
+}
+async function searchInDirectory(dirPath, searchTerm, caseSensitive = false, fileExtensions = []) {
+    const validPath = await validatePath(dirPath);
+    const results = [];
+    async function searchRecursive(currentPath, depth = 0) {
+        if (depth > 10)
+            return; // Prevent infinite recursion
+        try {
+            const entries = await fs.readdir(currentPath, { withFileTypes: true });
+            for (const entry of entries) {
+                const fullPath = path.join(currentPath, entry.name);
+                // Skip common directories that should be ignored
+                if (entry.isDirectory() && ['node_modules', '.git', '.DS_Store', 'dist', 'build'].includes(entry.name)) {
+                    continue;
+                }
+                if (entry.isDirectory()) {
+                    await searchRecursive(fullPath, depth + 1);
+                }
+                else if (entry.isFile()) {
+                    // Check file extension filter
+                    if (fileExtensions.length > 0) {
+                        const ext = path.extname(entry.name).toLowerCase();
+                        if (!fileExtensions.includes(ext)) {
+                            continue;
+                        }
+                    }
+                    try {
+                        const searchResult = await searchInFile(fullPath, searchTerm, caseSensitive);
+                        if (searchResult.matches > 0) {
+                            const relativePath = path.relative(workingDirectory, fullPath);
+                            results.push(`\n📁 ${relativePath} (${searchResult.matches} matches):`);
+                            results.push(...searchResult.lines.map(line => `  ${line}`));
+                        }
+                    }
+                    catch (error) {
+                        // Skip files we can't read
+                    }
+                }
+            }
+        }
+        catch (error) {
+            // Skip directories we can't read
+        }
+    }
+    await searchRecursive(validPath);
+    if (results.length === 0) {
+        return `No matches found for "${searchTerm}" in ${dirPath}`;
+    }
+    return results.join('\n');
+}
+export async function searchFiles(searchTerm, dirPath = '.', caseSensitive = false, fileExtensions = []) {
+    try {
+        if (!searchTerm.trim()) {
+            throw new Error('Search term cannot be empty');
+        }
+        const validPath = await validatePath(dirPath);
+        // Check if path exists and is a directory
+        const stats = await fs.stat(validPath);
+        if (!stats.isDirectory()) {
+            throw new Error('Search path must be a directory');
+        }
+        const results = await searchInDirectory(validPath, searchTerm, caseSensitive, fileExtensions);
+        const searchInfo = [
+            `🔍 Searching for: "${searchTerm}"`,
+            `📂 In directory: ${path.relative(workingDirectory, validPath) || '.'}`,
+            `📝 Case sensitive: ${caseSensitive ? 'Yes' : 'No'}`,
+            fileExtensions.length > 0 ? `🎯 File types: ${fileExtensions.join(', ')}` : '🎯 All file types',
+            '',
+        ].join('\n');
+        return searchInfo + results;
+    }
+    catch (error) {
+        if (error instanceof Error) {
+            throw new Error(`Failed to search files: ${error.message}`);
+        }
+        throw new Error('Failed to search files: Unknown error');
+    }
+}
+// Tool definitions
+export const searchTools = [
+    {
+        type: 'function',
+        function: {
+            name: 'search_files',
+            description: 'Search for a text string within files in a directory. Supports case sensitivity and file type filtering. Returns the list of files and matching lines. Use this to find specific code, configuration settings, or documentation within your project files.',
+            parameters: {
+                type: 'object',
+                properties: {
+                    search_term: {
+                        type: 'string',
+                        description: 'The text string to search for within files.'
+                    },
+                    directory_path: {
+                        type: 'string',
+                        description: 'The directory to search within, relative to the current working directory. Use "." for the current directory.'
+                    },
+                    case_sensitive: {
+                        type: 'boolean',
+                        description: 'Whether the search should be case sensitive.'
+                    },
+                    file_extensions: {
+                        type: 'array',
+                        items: {
+                            type: 'string',
+                            description: 'File extension to include in the search (e.g., "js", "txt"). Leave empty to search all file types.'
+                        },
+                        description: 'List of file extensions to include in the search.'
+                    }
+                },
+                required: ['search_term', 'directory_path']
+            }
+        }
+    }
+];