fileditor-mcp 1.0.0

package/test/InsertContentHandler.test.js

@@ -0,0 +1,371 @@
+import { InsertContentHandler } from '../src/handlers/insertContent.js';
+import { FileUtils } from '../src/utils/fileUtils.js';
+import { describe, it, beforeEach, afterEach } from 'node:test';
+import assert from 'node:assert';
+import fs from 'fs/promises';
+import { join } from 'path';
+import { existsSync } from 'fs';
+
+/**
+ * InsertContentHandler Test Class
+ * Test content insertion functionality
+ */
+describe('InsertContentHandler', () => {
+
+    const testDir = './test_files_insert';
+    const testFile1 = join(testDir, 'test1.txt');
+    const testFile2 = join(testDir, 'test2.txt');
+    const baseContent = 'Line 1\nLine 2\nLine 3\nLine 4\nLine 5';
+
+    beforeEach(async () => {
+        // Set test workspace
+        FileUtils.setWorkspaceRoot(process.cwd());
+
+        // Create test directory and files
+        if (!existsSync(testDir)) {
+            await fs.mkdir(testDir, { recursive: true });
+        }
+        await fs.writeFile(testFile1, baseContent, 'utf8');
+        await fs.writeFile(testFile2, baseContent, 'utf8');
+    });
+
+    afterEach(async () => {
+        // Clean up test files
+        try {
+            if (existsSync(testFile1)) await fs.unlink(testFile1);
+            if (existsSync(testFile2)) await fs.unlink(testFile2);
+            if (existsSync(testDir)) await fs.rmdir(testDir);
+        } catch (error) {
+            console.warn('Failed to clean up test files:', error.message);
+        }
+    });
+
+    describe('Single File Insertion', () => {
+
+        it('should insert content before the specified line number', async () => {
+            const args = {
+                path: testFile1,
+                line: 3,
+                content: 'Inserted line'
+            };
+
+            const result = await InsertContentHandler.handle(args);
+
+            assert.strictEqual(result.content[0].type, 'text');
+            assert.ok(result.content[0].text.includes('Successfully inserted'));
+            assert.ok(result.content[0].text.includes('line 3'));
+
+            // Verify file content
+            const content = await fs.readFile(testFile1, 'utf8');
+            const lines = content.split('\n');
+            assert.strictEqual(lines[2], 'Inserted line');
+            assert.strictEqual(lines[3], 'Line 3');
+            assert.strictEqual(lines.length, 6); // Originally 5 lines + 1 inserted line
+        });
+
+        it('should insert content at the beginning of the file', async () => {
+            const args = {
+                path: testFile1,
+                line: 1,
+                content: 'First line'
+            };
+
+            const result = await InsertContentHandler.handle(args);
+
+            assert.strictEqual(result.content[0].type, 'text');
+            assert.ok(result.content[0].text.includes('Successfully inserted'));
+
+            // Verify file content
+            const content = await fs.readFile(testFile1, 'utf8');
+            const lines = content.split('\n');
+            assert.strictEqual(lines[0], 'First line');
+            assert.strictEqual(lines[1], 'Line 1');
+        });
+
+        it('should insert content at the end of the file (line=0)', async () => {
+            const args = {
+                path: testFile1,
+                line: 0,
+                content: 'Last line'
+            };
+
+            const result = await InsertContentHandler.handle(args);
+
+            assert.strictEqual(result.content[0].type, 'text');
+            assert.ok(result.content[0].text.includes('end of file'));
+
+            // Verify file content
+            const content = await fs.readFile(testFile1, 'utf8');
+            const lines = content.split('\n');
+            assert.strictEqual(lines[lines.length - 1], 'Last line');
+            assert.strictEqual(lines.length, 6);
+        });
+
+        it('should support negative line numbers for insertion', async () => {
+            const args = {
+                path: testFile1,
+                line: -1, // Insert before the last line
+                content: 'Before last line'
+            };
+
+            const result = await InsertContentHandler.handle(args);
+
+            assert.strictEqual(result.content[0].type, 'text');
+            assert.ok(result.content[0].text.includes('from end'));
+
+            // Verify file content
+            const content = await fs.readFile(testFile1, 'utf8');
+            const lines = content.split('\n');
+            assert.strictEqual(lines[4], 'Before last line');
+            assert.strictEqual(lines[5], 'Line 5');
+        });
+
+        it('should support inserting multiple lines of content', async () => {
+            const multiLineContent = 'Line A\nLine B\nLine C';
+            const args = {
+                path: testFile1,
+                line: 2,
+                content: multiLineContent
+            };
+
+            const result = await InsertContentHandler.handle(args);
+
+            assert.strictEqual(result.content[0].type, 'text');
+            assert.ok(result.content[0].text.includes('3 line(s)'));
+
+            // Verify file content
+            const content = await fs.readFile(testFile1, 'utf8');
+            const lines = content.split('\n');
+            assert.strictEqual(lines[1], 'Line A');
+            assert.strictEqual(lines[2], 'Line B');
+            assert.strictEqual(lines[3], 'Line C');
+            assert.strictEqual(lines[4], 'Line 2');
+            assert.strictEqual(lines.length, 8); // Originally 5 lines + 3 inserted lines
+        });
+
+        it('should throw an error if the file does not exist', async () => {
+            const args = {
+                path: './nonexistent.txt',
+                line: 1,
+                content: 'Some content'
+            };
+
+            await assert.rejects(
+                () => InsertContentHandler.handle(args),
+                (error) => error.message.includes('File not found')
+            );
+        });
+
+        it('should throw an error if the line number is out of range', async () => {
+            const args = {
+                path: testFile1,
+                line: 10, // Exceeds file length
+                content: 'Some content'
+            };
+
+            await assert.rejects(
+                () => InsertContentHandler.handle(args),
+                (error) => error.message.includes('exceeds file length')
+            );
+        });
+
+        it('should throw an error if the negative line number is out of range', async () => {
+            const args = {
+                path: testFile1,
+                line: -10, // Negative number too large
+                content: 'Some content'
+            };
+
+            await assert.rejects(
+                () => InsertContentHandler.handle(args),
+                (error) => error.message.includes('out of range')
+            );
+        });
+
+    });
+
+    describe('Multiple Files Insertion', () => {
+
+        it('should insert the same content at the same position in multiple files', async () => {
+            const args = {
+                path: [testFile1, testFile2],
+                line: 2,
+                content: 'Common insert'
+            };
+
+            const result = await InsertContentHandler.handle(args);
+
+            assert.strictEqual(result.content[0].type, 'text');
+            assert.ok(result.content[0].text.includes('Successfully processed 2 file(s)'));
+
+            // Verify content in both files
+            const content1 = await fs.readFile(testFile1, 'utf8');
+            const content2 = await fs.readFile(testFile2, 'utf8');
+
+            const lines1 = content1.split('\n');
+            const lines2 = content2.split('\n');
+
+            assert.strictEqual(lines1[1], 'Common insert');
+            assert.strictEqual(lines2[1], 'Common insert');
+            assert.strictEqual(lines1[2], 'Line 2');
+            assert.strictEqual(lines2[2], 'Line 2');
+        });
+
+        it('should insert different content at different positions in multiple files', async () => {
+            const args = {
+                path: [testFile1, testFile2],
+                line: [1, 3],
+                content: ['Insert at start', 'Insert at middle']
+            };
+
+            const result = await InsertContentHandler.handle(args);
+
+            assert.strictEqual(result.content[0].type, 'text');
+            assert.ok(result.content[0].text.includes('Successfully processed 2 file(s)'));
+
+            // Verify file content
+            const content1 = await fs.readFile(testFile1, 'utf8');
+            const content2 = await fs.readFile(testFile2, 'utf8');
+
+            const lines1 = content1.split('\n');
+            const lines2 = content2.split('\n');
+
+            assert.strictEqual(lines1[0], 'Insert at start');
+            assert.strictEqual(lines1[1], 'Line 1');
+
+            assert.strictEqual(lines2[2], 'Insert at middle');
+            assert.strictEqual(lines2[3], 'Line 3');
+        });
+
+        it('should throw an error if the line number array lengths do not match', async () => {
+            const args = {
+                path: [testFile1, testFile2],
+                line: [1], // Only one line number, but two files
+                content: ['Content 1', 'Content 2']
+            };
+
+            await assert.rejects(
+                () => InsertContentHandler.handle(args),
+                (error) => error.message.includes('must match file count')
+            );
+        });
+
+        it('should throw an error if the content array lengths do not match', async () => {
+            const args = {
+                path: [testFile1, testFile2],
+                line: [1, 2],
+                content: ['Only one content'] // Only one content, but two files
+            };
+
+            await assert.rejects(
+                () => InsertContentHandler.handle(args),
+                (error) => error.message.includes('must match file count')
+            );
+        });
+
+        it('should handle cases where some file operations fail', async () => {
+            const nonexistentFile = './nonexistent.txt';
+            const args = {
+                path: [testFile1, nonexistentFile],
+                line: [1, 1],
+                content: ['Valid content', 'Invalid content']
+            };
+
+            const result = await InsertContentHandler.handle(args);
+
+            assert.strictEqual(result.content[0].type, 'text');
+            const text = result.content[0].text;
+
+            assert.ok(text.includes('Successfully processed 1 file(s)'));
+            assert.ok(text.includes('Errors encountered'));
+            assert.ok(text.includes('File not found'));
+        });
+
+    });
+
+    describe('Edge Cases', () => {
+
+        it('should handle empty file insertion', async () => {
+            const emptyFile = join(testDir, 'empty.txt');
+            await fs.writeFile(emptyFile, '', 'utf8');
+
+            const args = {
+                path: emptyFile,
+                line: 0,
+                content: 'First content in empty file'
+            };
+
+            const result = await InsertContentHandler.handle(args);
+
+            assert.strictEqual(result.content[0].type, 'text');
+            assert.ok(result.content[0].text.includes('Successfully inserted'));
+            // Verify content
+            const content = await fs.readFile(emptyFile, 'utf8');
+            assert.strictEqual(content, '\nFirst content in empty file'); // Fix expected value
+
+            await fs.unlink(emptyFile);
+        });
+
+        it('should handle content with special characters', async () => {
+            const specialContent = 'Special: áéíóú Chinese @#$%^&*()';
+            const args = {
+                path: testFile1,
+                line: 1,
+                content: specialContent
+            };
+
+            const result = await InsertContentHandler.handle(args);
+
+            assert.strictEqual(result.content[0].type, 'text');
+            assert.ok(result.content[0].text.includes('Successfully inserted'));
+
+            // Verify special characters inserted correctly
+            const content = await fs.readFile(testFile1, 'utf8');
+            const lines = content.split('\n');
+            assert.strictEqual(lines[0], specialContent);
+        });
+
+        it('should handle empty string insertion', async () => {
+            const args = {
+                path: testFile1,
+                line: 2,
+                content: ''
+            };
+
+            const result = await InsertContentHandler.handle(args);
+
+            assert.strictEqual(result.content[0].type, 'text');
+            assert.ok(result.content[0].text.includes('Successfully inserted'));
+
+            // Verify empty line inserted
+            const content = await fs.readFile(testFile1, 'utf8');
+            const lines = content.split('\n');
+            assert.strictEqual(lines[1], '');
+            assert.strictEqual(lines[2], 'Line 2');
+        });
+
+        it('should handle large content insertion', async () => {
+            const bigContent = Array.from({ length: 100 }, (_, i) => `Big line ${i + 1}`).join('\n');
+            const args = {
+                path: testFile1,
+                line: 3,
+                content: bigContent
+            };
+
+            const result = await InsertContentHandler.handle(args);
+
+            assert.strictEqual(result.content[0].type, 'text');
+            assert.ok(result.content[0].text.includes('100 line(s)'));
+
+            // Verify file line count
+            const content = await fs.readFile(testFile1, 'utf8');
+            const lines = content.split('\n');
+            assert.strictEqual(lines.length, 105); // Originally 5 lines + 100 inserted lines
+            assert.strictEqual(lines[2], 'Big line 1');
+            assert.strictEqual(lines[101], 'Big line 100');
+            assert.strictEqual(lines[102], 'Line 3');
+        });
+
+    });
+
+});

package/test/ListFilesHandler.test.js

@@ -0,0 +1,302 @@
+import { ListFilesHandler } from '../src/handlers/listFiles.js';
+import { FileUtils } from '../src/utils/fileUtils.js';
+import { describe, it, beforeEach, afterEach } from 'node:test';
+import assert from 'node:assert';
+import fs from 'fs/promises';
+import { join } from 'path';
+import { existsSync } from 'fs';
+
+/**
+ * Test suite for ListFilesHandler.
+ * Tests the file listing functionality.
+ */
+describe('ListFilesHandler', () => {
+
+    const testDir = './test_files_list';
+    const subDir1 = join(testDir, 'subdir1');
+    const subDir2 = join(testDir, 'subdir2');
+    const file1 = join(testDir, 'file1.txt');
+    const file2 = join(testDir, 'file2.js');
+    const subFile1 = join(subDir1, 'subfile1.txt');
+    const subFile2 = join(subDir2, 'subfile2.md');
+
+    beforeEach(async () => {
+        // Set up the test workspace
+        FileUtils.setWorkspaceRoot(process.cwd());
+
+        // Create test directory structure
+        await fs.mkdir(testDir, { recursive: true });
+        await fs.mkdir(subDir1, { recursive: true });
+        await fs.mkdir(subDir2, { recursive: true });
+
+        // Create test files
+        await fs.writeFile(file1, 'File 1 content', 'utf8');
+        await fs.writeFile(file2, 'File 2 content', 'utf8');
+        await fs.writeFile(subFile1, 'Sub file 1 content', 'utf8');
+        await fs.writeFile(subFile2, 'Sub file 2 content', 'utf8');
+    });
+
+    afterEach(async () => {
+        // Clean up test files and directories
+        try {
+            if (existsSync(subFile1)) await fs.unlink(subFile1);
+            if (existsSync(subFile2)) await fs.unlink(subFile2);
+            if (existsSync(file1)) await fs.unlink(file1);
+            if (existsSync(file2)) await fs.unlink(file2);
+            if (existsSync(subDir1)) await fs.rmdir(subDir1);
+            if (existsSync(subDir2)) await fs.rmdir(subDir2);
+            if (existsSync(testDir)) await fs.rmdir(testDir);
+        } catch (error) {
+            console.warn('Failed to clean up test files:', error.message);
+        }
+    });
+
+    describe('Non-recursive listing', () => {
+
+        it('should list files and subdirectories in a directory', async () => {
+            const args = { path: testDir };
+
+            const result = await ListFilesHandler.handle(args);
+
+            assert.strictEqual(result.content[0].type, 'text');
+            const text = result.content[0].text;
+
+            // Check for files
+            assert.ok(text.includes('file: file1.txt'));
+            assert.ok(text.includes('file: file2.js'));
+
+            // Check for directories
+            assert.ok(text.includes('directory: subdir1'));
+            assert.ok(text.includes('directory: subdir2'));
+
+            // Should not include files from subdirectories
+            assert.ok(!text.includes('subfile1.txt'));
+            assert.ok(!text.includes('subfile2.md'));
+        });
+
+        it('should handle empty directories', async () => {
+            const emptyDir = join(testDir, 'empty');
+            await fs.mkdir(emptyDir);
+
+            const args = { path: emptyDir };
+
+            const result = await ListFilesHandler.handle(args);
+
+            assert.strictEqual(result.content[0].type, 'text');
+            const text = result.content[0].text;
+            assert.strictEqual(text.trim(), '');
+
+            await fs.rmdir(emptyDir);
+        });
+
+        it('should throw an error when the directory does not exist', async () => {
+            const args = { path: './nonexistent_directory' };
+
+            await assert.rejects(
+                () => ListFilesHandler.handle(args),
+                (error) => error.message.includes('Failed to list files') &&
+                    error.message.includes('Directory not found')
+            );
+        });
+
+    });
+
+    describe('Recursive listing', () => {
+
+        it('should recursively list all files and directories', async () => {
+            const args = {
+                path: testDir,
+                recursive: true
+            };
+
+            const result = await ListFilesHandler.handle(args);
+
+            assert.strictEqual(result.content[0].type, 'text');
+            const text = result.content[0].text;
+
+            // Check for root directory files
+            assert.ok(text.includes('file: file1.txt'));
+            assert.ok(text.includes('file: file2.js'));
+
+            // Check for root directory subdirectories
+            assert.ok(text.includes('directory: subdir1'));
+            assert.ok(text.includes('directory: subdir2'));
+
+            // Check for files in subdirectories
+            assert.ok(text.includes('file: subdir1/subfile1.txt'));
+            assert.ok(text.includes('file: subdir2/subfile2.md'));
+        });
+
+        it('should handle deeply nested directories', async () => {
+            // Create a deeper directory structure
+            const deepDir = join(subDir1, 'deep');
+            const deeperDir = join(deepDir, 'deeper');
+            const deepFile = join(deeperDir, 'deep_file.txt');
+
+            await fs.mkdir(deepDir);
+            await fs.mkdir(deeperDir);
+            await fs.writeFile(deepFile, 'Deep file content', 'utf8');
+
+            const args = {
+                path: testDir,
+                recursive: true
+            };
+
+            const result = await ListFilesHandler.handle(args);
+
+            assert.strictEqual(result.content[0].type, 'text');
+            const text = result.content[0].text;
+
+            assert.ok(text.includes('directory: subdir1/deep'));
+            assert.ok(text.includes('directory: subdir1/deep/deeper'));
+            assert.ok(text.includes('file: subdir1/deep/deeper/deep_file.txt'));
+
+            // Clean up deep files
+            await fs.unlink(deepFile);
+            await fs.rmdir(deeperDir);
+            await fs.rmdir(deepDir);
+        });
+
+        it('should handle cases with only subdirectories', async () => {
+            const onlyDirsPath = join(testDir, 'only_dirs');
+            const childDir1 = join(onlyDirsPath, 'child1');
+            const childDir2 = join(onlyDirsPath, 'child2');
+
+            await fs.mkdir(onlyDirsPath);
+            await fs.mkdir(childDir1);
+            await fs.mkdir(childDir2);
+
+            const args = {
+                path: onlyDirsPath,
+                recursive: true
+            };
+
+            const result = await ListFilesHandler.handle(args);
+
+            assert.strictEqual(result.content[0].type, 'text');
+            const text = result.content[0].text;
+
+            assert.ok(text.includes('directory: child1'));
+            assert.ok(text.includes('directory: child2'));
+            assert.ok(!text.includes('file:'));
+
+            // Cleanup
+            await fs.rmdir(childDir1);
+            await fs.rmdir(childDir2);
+            await fs.rmdir(onlyDirsPath);
+        });
+
+    });
+
+    describe('Path handling', () => {
+
+        it('should handle relative paths', async () => {
+            const args = { path: './test_files_list' };
+
+            const result = await ListFilesHandler.handle(args);
+
+            assert.strictEqual(result.content[0].type, 'text');
+            const text = result.content[0].text;
+            assert.ok(text.includes('file: file1.txt'));
+        });
+
+        it('should handle absolute paths', async () => {
+            const absolutePath = join(process.cwd(), testDir);
+            const args = { path: absolutePath };
+
+            const result = await ListFilesHandler.handle(args);
+
+            assert.strictEqual(result.content[0].type, 'text');
+            const text = result.content[0].text;
+            assert.ok(text.includes('file: file1.txt'));
+        });
+
+        it('should handle special characters in paths', async () => {
+            const specialDir = join(testDir, 'special dir with spaces');
+            const specialFile = join(specialDir, 'special-file_123.txt');
+
+            await fs.mkdir(specialDir);
+            await fs.writeFile(specialFile, 'Special content', 'utf8');
+
+            const args = { path: specialDir };
+
+            const result = await ListFilesHandler.handle(args);
+
+            assert.strictEqual(result.content[0].type, 'text');
+            const text = result.content[0].text;
+            assert.ok(text.includes('file: special-file_123.txt'));
+
+            // Cleanup
+            await fs.unlink(specialFile);
+            await fs.rmdir(specialDir);
+        });
+
+    });
+
+    describe('Edge cases', () => {
+
+        it('should handle directories with a large number of files', async () => {
+            const manyFilesDir = join(testDir, 'many_files');
+            await fs.mkdir(manyFilesDir);
+
+            // Create 100 files
+            const files = [];
+            for (let i = 0; i < 100; i++) {
+                const file = join(manyFilesDir, `file_${i.toString().padStart(3, '0')}.txt`);
+                await fs.writeFile(file, `Content ${i}`, 'utf8');
+                files.push(file);
+            }
+
+            const args = { path: manyFilesDir };
+
+            const result = await ListFilesHandler.handle(args);
+
+            assert.strictEqual(result.content[0].type, 'text');
+            const text = result.content[0].text;
+
+            // Check if some files exist
+            assert.ok(text.includes('file: file_000.txt'));
+            assert.ok(text.includes('file: file_050.txt'));
+            assert.ok(text.includes('file: file_099.txt'));
+
+            // Clean up files
+            for (const file of files) {
+                await fs.unlink(file);
+            }
+            await fs.rmdir(manyFilesDir);
+        });
+
+        it('should handle sorting of file and directory names', async () => {
+            const sortDir = join(testDir, 'sort_test');
+            await fs.mkdir(sortDir);
+
+            // Create some files and directories to test sorting
+            await fs.writeFile(join(sortDir, 'z_file.txt'), 'content', 'utf8');
+            await fs.writeFile(join(sortDir, 'a_file.txt'), 'content', 'utf8');
+            await fs.mkdir(join(sortDir, 'z_dir'));
+            await fs.mkdir(join(sortDir, 'a_dir'));
+
+            const args = { path: sortDir };
+
+            const result = await ListFilesHandler.handle(args);
+
+            assert.strictEqual(result.content[0].type, 'text');
+            const text = result.content[0].text;
+
+            // Verify all items are listed
+            assert.ok(text.includes('file: a_file.txt'));
+            assert.ok(text.includes('file: z_file.txt'));
+            assert.ok(text.includes('directory: a_dir'));
+            assert.ok(text.includes('directory: z_dir'));
+
+            // Cleanup
+            await fs.unlink(join(sortDir, 'z_file.txt'));
+            await fs.unlink(join(sortDir, 'a_file.txt'));
+            await fs.rmdir(join(sortDir, 'z_dir'));
+            await fs.rmdir(join(sortDir, 'a_dir'));
+            await fs.rmdir(sortDir);
+        });
+
+    });
+
+});