@ggakila/agentx-framework 0.1.0

package/dist/integrations/FileSystemTool.js

@@ -0,0 +1,835 @@
+"use strict";
+/**
+ * File System Integration Tools
+ * Provides integrations for local file system, S3, and FTP/SFTP
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.FTPTool = exports.ftpToolSpec = exports.S3Tool = exports.s3ToolSpec = exports.LocalFileSystemTool = exports.localFileSystemToolSpec = void 0;
+/**
+ * Local File System Tool Specification
+ */
+exports.localFileSystemToolSpec = {
+    name: 'local-filesystem',
+    version: '1.0.0',
+    description: 'Perform local file system operations',
+    inputSchema: {
+        type: 'object',
+        properties: {
+            action: {
+                type: 'string',
+                enum: ['read', 'write', 'append', 'delete', 'list', 'mkdir', 'rmdir', 'copy', 'move', 'exists', 'stat'],
+                description: 'File system action',
+            },
+            path: { type: 'string', description: 'File or directory path' },
+            content: { type: 'string', description: 'Content to write' },
+            encoding: { type: 'string', description: 'File encoding (default: utf8)' },
+            destination: { type: 'string', description: 'Destination path for copy/move' },
+            recursive: { type: 'boolean', description: 'Recursive operation' },
+        },
+        required: ['action', 'path'],
+    },
+    outputSchema: {
+        type: 'object',
+        properties: {
+            success: { type: 'boolean' },
+            content: { type: 'string' },
+            files: { type: 'array' },
+            stat: { type: 'object' },
+        },
+    },
+};
+/**
+ * Local File System Integration (In-memory implementation for testing)
+ */
+class LocalFileSystemTool {
+    config;
+    logger;
+    files = new Map();
+    constructor(config, logger) {
+        this.config = { ...config, type: 'local' };
+        this.logger = logger;
+        // Create root directory
+        this.files.set('/', { content: '', isDirectory: true, createdAt: new Date(), modifiedAt: new Date() });
+    }
+    async execute(input) {
+        try {
+            const normalizedPath = this.normalizePath(input.path);
+            switch (input.action) {
+                case 'read': return this.readFile(normalizedPath);
+                case 'write': return this.writeFile(normalizedPath, input.content || '');
+                case 'append': return this.appendFile(normalizedPath, input.content || '');
+                case 'delete': return this.deleteFile(normalizedPath);
+                case 'list': return this.listDirectory(normalizedPath);
+                case 'mkdir': return this.makeDirectory(normalizedPath, input.recursive);
+                case 'rmdir': return this.removeDirectory(normalizedPath, input.recursive);
+                case 'copy': return this.copyFile(normalizedPath, this.normalizePath(input.destination));
+                case 'move': return this.moveFile(normalizedPath, this.normalizePath(input.destination));
+                case 'exists': return this.exists(normalizedPath);
+                case 'stat': return this.stat(normalizedPath);
+                default:
+                    return { success: false, error: `Unknown action: ${input.action}` };
+            }
+        }
+        catch (error) {
+            this.logger.error('File system error', error);
+            return { success: false, error: error.message };
+        }
+    }
+    normalizePath(path) {
+        // Normalize path separators and remove trailing slashes
+        let normalized = path.replace(/\\/g, '/').replace(/\/+/g, '/');
+        if (normalized !== '/' && normalized.endsWith('/')) {
+            normalized = normalized.slice(0, -1);
+        }
+        if (!normalized.startsWith('/')) {
+            normalized = '/' + normalized;
+        }
+        return normalized;
+    }
+    getParentPath(path) {
+        const parts = path.split('/').filter(Boolean);
+        parts.pop();
+        return '/' + parts.join('/');
+    }
+    async readFile(path) {
+        const file = this.files.get(path);
+        if (!file) {
+            return { success: false, error: `File not found: ${path}` };
+        }
+        if (file.isDirectory) {
+            return { success: false, error: `Cannot read directory: ${path}` };
+        }
+        return {
+            success: true,
+            data: { content: file.content, path },
+        };
+    }
+    async writeFile(path, content) {
+        // Ensure parent directory exists
+        const parentPath = this.getParentPath(path);
+        if (parentPath !== '/' && !this.files.has(parentPath)) {
+            return { success: false, error: `Parent directory does not exist: ${parentPath}` };
+        }
+        const existing = this.files.get(path);
+        if (existing?.isDirectory) {
+            return { success: false, error: `Cannot write to directory: ${path}` };
+        }
+        this.files.set(path, {
+            content,
+            isDirectory: false,
+            createdAt: existing?.createdAt || new Date(),
+            modifiedAt: new Date(),
+        });
+        this.logger.info('File written', { path, size: content.length });
+        return {
+            success: true,
+            data: { path, size: content.length },
+        };
+    }
+    async appendFile(path, content) {
+        const file = this.files.get(path);
+        if (file?.isDirectory) {
+            return { success: false, error: `Cannot append to directory: ${path}` };
+        }
+        const existingContent = file?.content || '';
+        const newContent = existingContent + content;
+        this.files.set(path, {
+            content: newContent,
+            isDirectory: false,
+            createdAt: file?.createdAt || new Date(),
+            modifiedAt: new Date(),
+        });
+        this.logger.info('Content appended to file', { path, appendedSize: content.length });
+        return {
+            success: true,
+            data: { path, size: newContent.length },
+        };
+    }
+    async deleteFile(path) {
+        const file = this.files.get(path);
+        if (!file) {
+            return { success: false, error: `File not found: ${path}` };
+        }
+        if (file.isDirectory) {
+            return { success: false, error: `Cannot delete directory with delete action, use rmdir: ${path}` };
+        }
+        this.files.delete(path);
+        this.logger.info('File deleted', { path });
+        return {
+            success: true,
+            data: { path, deleted: true },
+        };
+    }
+    async listDirectory(path) {
+        const dir = this.files.get(path);
+        if (!dir) {
+            return { success: false, error: `Directory not found: ${path}` };
+        }
+        if (!dir.isDirectory) {
+            return { success: false, error: `Not a directory: ${path}` };
+        }
+        const prefix = path === '/' ? '/' : path + '/';
+        const files = [];
+        for (const [filePath, file] of this.files.entries()) {
+            if (filePath !== path && filePath.startsWith(prefix)) {
+                const relativePath = filePath.slice(prefix.length);
+                // Only include direct children (no nested paths)
+                if (!relativePath.includes('/')) {
+                    files.push({
+                        name: relativePath,
+                        path: filePath,
+                        size: file.content.length,
+                        isDirectory: file.isDirectory,
+                        createdAt: file.createdAt,
+                        modifiedAt: file.modifiedAt,
+                    });
+                }
+            }
+        }
+        return {
+            success: true,
+            data: { path, files },
+        };
+    }
+    async makeDirectory(path, recursive) {
+        if (this.files.has(path)) {
+            const existing = this.files.get(path);
+            if (existing.isDirectory) {
+                return { success: true, data: { path, created: false, exists: true } };
+            }
+            return { success: false, error: `Path exists and is not a directory: ${path}` };
+        }
+        // Check parent exists
+        const parentPath = this.getParentPath(path);
+        if (parentPath !== '/' && !this.files.has(parentPath)) {
+            if (recursive) {
+                await this.makeDirectory(parentPath, true);
+            }
+            else {
+                return { success: false, error: `Parent directory does not exist: ${parentPath}` };
+            }
+        }
+        this.files.set(path, {
+            content: '',
+            isDirectory: true,
+            createdAt: new Date(),
+            modifiedAt: new Date(),
+        });
+        this.logger.info('Directory created', { path });
+        return {
+            success: true,
+            data: { path, created: true },
+        };
+    }
+    async removeDirectory(path, recursive) {
+        if (path === '/') {
+            return { success: false, error: 'Cannot remove root directory' };
+        }
+        const dir = this.files.get(path);
+        if (!dir) {
+            return { success: false, error: `Directory not found: ${path}` };
+        }
+        if (!dir.isDirectory) {
+            return { success: false, error: `Not a directory: ${path}` };
+        }
+        // Check if directory is empty
+        const prefix = path + '/';
+        const children = Array.from(this.files.keys()).filter(p => p.startsWith(prefix));
+        if (children.length > 0) {
+            if (recursive) {
+                // Delete all children
+                for (const childPath of children) {
+                    this.files.delete(childPath);
+                }
+            }
+            else {
+                return { success: false, error: `Directory not empty: ${path}` };
+            }
+        }
+        this.files.delete(path);
+        this.logger.info('Directory removed', { path, recursive });
+        return {
+            success: true,
+            data: { path, removed: true },
+        };
+    }
+    async copyFile(source, destination) {
+        const file = this.files.get(source);
+        if (!file) {
+            return { success: false, error: `Source not found: ${source}` };
+        }
+        // Ensure destination parent exists
+        const destParent = this.getParentPath(destination);
+        if (destParent !== '/' && !this.files.has(destParent)) {
+            return { success: false, error: `Destination parent does not exist: ${destParent}` };
+        }
+        this.files.set(destination, {
+            content: file.content,
+            isDirectory: file.isDirectory,
+            createdAt: new Date(),
+            modifiedAt: new Date(),
+        });
+        this.logger.info('File copied', { source, destination });
+        return {
+            success: true,
+            data: { source, destination, copied: true },
+        };
+    }
+    async moveFile(source, destination) {
+        const copyResult = await this.copyFile(source, destination);
+        if (!copyResult.success) {
+            return copyResult;
+        }
+        this.files.delete(source);
+        this.logger.info('File moved', { source, destination });
+        return {
+            success: true,
+            data: { source, destination, moved: true },
+        };
+    }
+    async exists(path) {
+        return {
+            success: true,
+            data: { path, exists: this.files.has(path) },
+        };
+    }
+    async stat(path) {
+        const file = this.files.get(path);
+        if (!file) {
+            return { success: false, error: `Path not found: ${path}` };
+        }
+        return {
+            success: true,
+            data: {
+                path,
+                size: file.content.length,
+                isDirectory: file.isDirectory,
+                createdAt: file.createdAt.toISOString(),
+                modifiedAt: file.modifiedAt.toISOString(),
+            },
+        };
+    }
+    // Test helpers
+    getFiles() {
+        return new Map(this.files);
+    }
+    clearFiles() {
+        this.files.clear();
+        this.files.set('/', { content: '', isDirectory: true, createdAt: new Date(), modifiedAt: new Date() });
+    }
+}
+exports.LocalFileSystemTool = LocalFileSystemTool;
+/**
+ * S3 Tool Specification
+ */
+exports.s3ToolSpec = {
+    name: 's3',
+    version: '1.0.0',
+    description: 'Interact with Amazon S3 storage',
+    inputSchema: {
+        type: 'object',
+        properties: {
+            action: {
+                type: 'string',
+                enum: ['getObject', 'putObject', 'deleteObject', 'listObjects', 'copyObject', 'headObject', 'createBucket', 'deleteBucket', 'listBuckets'],
+                description: 'S3 action',
+            },
+            bucket: { type: 'string', description: 'Bucket name' },
+            key: { type: 'string', description: 'Object key' },
+            body: { type: 'string', description: 'Object content' },
+            contentType: { type: 'string', description: 'Content type' },
+            sourceKey: { type: 'string', description: 'Source key for copy' },
+            sourceBucket: { type: 'string', description: 'Source bucket for copy' },
+            prefix: { type: 'string', description: 'Prefix for listing' },
+            maxKeys: { type: 'number', description: 'Max keys to return' },
+        },
+        required: ['action'],
+    },
+    outputSchema: {
+        type: 'object',
+        properties: {
+            success: { type: 'boolean' },
+            body: { type: 'string' },
+            objects: { type: 'array' },
+            buckets: { type: 'array' },
+        },
+    },
+};
+/**
+ * S3 Integration (In-memory implementation for testing)
+ */
+class S3Tool {
+    config;
+    logger;
+    buckets = new Map();
+    constructor(config, logger) {
+        this.config = { ...config, type: 's3' };
+        this.logger = logger;
+    }
+    async execute(input) {
+        try {
+            switch (input.action) {
+                case 'getObject': return this.getObject(input.bucket, input.key);
+                case 'putObject': return this.putObject(input.bucket, input.key, input.body, input.contentType);
+                case 'deleteObject': return this.deleteObject(input.bucket, input.key);
+                case 'listObjects': return this.listObjects(input.bucket, input.prefix, input.maxKeys);
+                case 'copyObject': return this.copyObject(input.sourceBucket, input.sourceKey, input.bucket, input.key);
+                case 'headObject': return this.headObject(input.bucket, input.key);
+                case 'createBucket': return this.createBucket(input.bucket);
+                case 'deleteBucket': return this.deleteBucket(input.bucket);
+                case 'listBuckets': return this.listBuckets();
+                default:
+                    return { success: false, error: `Unknown action: ${input.action}` };
+            }
+        }
+        catch (error) {
+            this.logger.error('S3 error', error);
+            return { success: false, error: error.message };
+        }
+    }
+    async getObject(bucket, key) {
+        if (!bucket || !key) {
+            return { success: false, error: 'Bucket and key are required' };
+        }
+        const bucketData = this.buckets.get(bucket);
+        if (!bucketData) {
+            return { success: false, error: `Bucket not found: ${bucket}` };
+        }
+        const object = bucketData.get(key);
+        if (!object) {
+            return { success: false, error: `Object not found: ${key}` };
+        }
+        return {
+            success: true,
+            data: {
+                body: object.body,
+                contentType: object.contentType,
+                contentLength: object.size,
+                lastModified: object.lastModified.toISOString(),
+                etag: object.etag,
+            },
+        };
+    }
+    async putObject(bucket, key, body, contentType) {
+        if (!bucket || !key) {
+            return { success: false, error: 'Bucket and key are required' };
+        }
+        let bucketData = this.buckets.get(bucket);
+        if (!bucketData) {
+            // Auto-create bucket
+            bucketData = new Map();
+            this.buckets.set(bucket, bucketData);
+        }
+        const etag = `"${this.generateETag(body)}"`;
+        bucketData.set(key, {
+            key,
+            body: body || '',
+            contentType: contentType || 'application/octet-stream',
+            size: (body || '').length,
+            lastModified: new Date(),
+            etag,
+        });
+        this.logger.info('S3 object uploaded', { bucket, key });
+        return {
+            success: true,
+            data: { etag, versionId: null },
+        };
+    }
+    async deleteObject(bucket, key) {
+        if (!bucket || !key) {
+            return { success: false, error: 'Bucket and key are required' };
+        }
+        const bucketData = this.buckets.get(bucket);
+        if (!bucketData) {
+            return { success: false, error: `Bucket not found: ${bucket}` };
+        }
+        bucketData.delete(key);
+        this.logger.info('S3 object deleted', { bucket, key });
+        return {
+            success: true,
+            data: { deleted: true },
+        };
+    }
+    async listObjects(bucket, prefix, maxKeys) {
+        if (!bucket) {
+            return { success: false, error: 'Bucket is required' };
+        }
+        const bucketData = this.buckets.get(bucket);
+        if (!bucketData) {
+            return { success: false, error: `Bucket not found: ${bucket}` };
+        }
+        let objects = Array.from(bucketData.values());
+        if (prefix) {
+            objects = objects.filter(obj => obj.key.startsWith(prefix));
+        }
+        if (maxKeys) {
+            objects = objects.slice(0, maxKeys);
+        }
+        return {
+            success: true,
+            data: {
+                contents: objects.map(obj => ({
+                    key: obj.key,
+                    size: obj.size,
+                    lastModified: obj.lastModified.toISOString(),
+                    etag: obj.etag,
+                })),
+                isTruncated: false,
+                keyCount: objects.length,
+            },
+        };
+    }
+    async copyObject(sourceBucket, sourceKey, destBucket, destKey) {
+        if (!sourceBucket || !sourceKey || !destBucket || !destKey) {
+            return { success: false, error: 'Source and destination bucket/key are required' };
+        }
+        const sourceBucketData = this.buckets.get(sourceBucket);
+        if (!sourceBucketData) {
+            return { success: false, error: `Source bucket not found: ${sourceBucket}` };
+        }
+        const sourceObject = sourceBucketData.get(sourceKey);
+        if (!sourceObject) {
+            return { success: false, error: `Source object not found: ${sourceKey}` };
+        }
+        let destBucketData = this.buckets.get(destBucket);
+        if (!destBucketData) {
+            destBucketData = new Map();
+            this.buckets.set(destBucket, destBucketData);
+        }
+        destBucketData.set(destKey, {
+            ...sourceObject,
+            key: destKey,
+            lastModified: new Date(),
+        });
+        this.logger.info('S3 object copied', { sourceBucket, sourceKey, destBucket, destKey });
+        return {
+            success: true,
+            data: { copyObjectResult: { etag: sourceObject.etag } },
+        };
+    }
+    async headObject(bucket, key) {
+        if (!bucket || !key) {
+            return { success: false, error: 'Bucket and key are required' };
+        }
+        const bucketData = this.buckets.get(bucket);
+        if (!bucketData) {
+            return { success: false, error: `Bucket not found: ${bucket}` };
+        }
+        const object = bucketData.get(key);
+        if (!object) {
+            return { success: false, error: `Object not found: ${key}` };
+        }
+        return {
+            success: true,
+            data: {
+                contentType: object.contentType,
+                contentLength: object.size,
+                lastModified: object.lastModified.toISOString(),
+                etag: object.etag,
+            },
+        };
+    }
+    async createBucket(bucket) {
+        if (!bucket) {
+            return { success: false, error: 'Bucket name is required' };
+        }
+        if (this.buckets.has(bucket)) {
+            return { success: false, error: `Bucket already exists: ${bucket}` };
+        }
+        this.buckets.set(bucket, new Map());
+        this.logger.info('S3 bucket created', { bucket });
+        return {
+            success: true,
+            data: { location: `/${bucket}` },
+        };
+    }
+    async deleteBucket(bucket) {
+        if (!bucket) {
+            return { success: false, error: 'Bucket name is required' };
+        }
+        const bucketData = this.buckets.get(bucket);
+        if (!bucketData) {
+            return { success: false, error: `Bucket not found: ${bucket}` };
+        }
+        if (bucketData.size > 0) {
+            return { success: false, error: `Bucket not empty: ${bucket}` };
+        }
+        this.buckets.delete(bucket);
+        this.logger.info('S3 bucket deleted', { bucket });
+        return {
+            success: true,
+            data: { deleted: true },
+        };
+    }
+    async listBuckets() {
+        const buckets = Array.from(this.buckets.keys()).map(name => ({
+            name,
+            creationDate: new Date().toISOString(),
+        }));
+        return {
+            success: true,
+            data: { buckets },
+        };
+    }
+    generateETag(content) {
+        // Simple hash for testing
+        let hash = 0;
+        for (let i = 0; i < content.length; i++) {
+            const char = content.charCodeAt(i);
+            hash = ((hash << 5) - hash) + char;
+            hash = hash & hash;
+        }
+        return Math.abs(hash).toString(16).padStart(32, '0');
+    }
+    // Test helpers
+    getBuckets() {
+        return new Map(this.buckets);
+    }
+    clearBuckets() {
+        this.buckets.clear();
+    }
+}
+exports.S3Tool = S3Tool;
+/**
+ * FTP/SFTP Tool Specification
+ */
+exports.ftpToolSpec = {
+    name: 'ftp',
+    version: '1.0.0',
+    description: 'Interact with FTP/SFTP servers',
+    inputSchema: {
+        type: 'object',
+        properties: {
+            action: {
+                type: 'string',
+                enum: ['get', 'put', 'delete', 'list', 'mkdir', 'rmdir', 'rename', 'exists'],
+                description: 'FTP action',
+            },
+            remotePath: { type: 'string', description: 'Remote file/directory path' },
+            localContent: { type: 'string', description: 'Content to upload' },
+            newPath: { type: 'string', description: 'New path for rename' },
+        },
+        required: ['action', 'remotePath'],
+    },
+    outputSchema: {
+        type: 'object',
+        properties: {
+            success: { type: 'boolean' },
+            content: { type: 'string' },
+            files: { type: 'array' },
+        },
+    },
+};
+/**
+ * FTP/SFTP Integration (In-memory implementation for testing)
+ */
+class FTPTool {
+    config;
+    logger;
+    files = new Map();
+    connected = false;
+    constructor(config, logger) {
+        this.config = config;
+        this.logger = logger;
+        // Create root directory
+        this.files.set('/', { content: '', isDirectory: true, modifiedAt: new Date() });
+    }
+    async connect() {
+        this.connected = true;
+        this.logger.info('FTP connected', { host: this.config.host });
+        return { success: true, data: { connected: true } };
+    }
+    async disconnect() {
+        this.connected = false;
+        this.logger.info('FTP disconnected');
+        return { success: true, data: { disconnected: true } };
+    }
+    async execute(input) {
+        try {
+            const normalizedPath = this.normalizePath(input.remotePath);
+            switch (input.action) {
+                case 'get': return this.getFile(normalizedPath);
+                case 'put': return this.putFile(normalizedPath, input.localContent || '');
+                case 'delete': return this.deleteFile(normalizedPath);
+                case 'list': return this.listDirectory(normalizedPath);
+                case 'mkdir': return this.makeDirectory(normalizedPath);
+                case 'rmdir': return this.removeDirectory(normalizedPath);
+                case 'rename': return this.renameFile(normalizedPath, this.normalizePath(input.newPath));
+                case 'exists': return this.exists(normalizedPath);
+                default:
+                    return { success: false, error: `Unknown action: ${input.action}` };
+            }
+        }
+        catch (error) {
+            this.logger.error('FTP error', error);
+            return { success: false, error: error.message };
+        }
+    }
+    normalizePath(path) {
+        let normalized = path.replace(/\\/g, '/').replace(/\/+/g, '/');
+        if (normalized !== '/' && normalized.endsWith('/')) {
+            normalized = normalized.slice(0, -1);
+        }
+        if (!normalized.startsWith('/')) {
+            normalized = '/' + normalized;
+        }
+        return normalized;
+    }
+    getParentPath(path) {
+        const parts = path.split('/').filter(Boolean);
+        parts.pop();
+        return '/' + parts.join('/');
+    }
+    async getFile(remotePath) {
+        const file = this.files.get(remotePath);
+        if (!file) {
+            return { success: false, error: `File not found: ${remotePath}` };
+        }
+        if (file.isDirectory) {
+            return { success: false, error: `Cannot download directory: ${remotePath}` };
+        }
+        return {
+            success: true,
+            data: { content: file.content, path: remotePath },
+        };
+    }
+    async putFile(remotePath, content) {
+        const parentPath = this.getParentPath(remotePath);
+        if (parentPath !== '/' && !this.files.has(parentPath)) {
+            return { success: false, error: `Parent directory does not exist: ${parentPath}` };
+        }
+        this.files.set(remotePath, {
+            content,
+            isDirectory: false,
+            modifiedAt: new Date(),
+        });
+        this.logger.info('FTP file uploaded', { path: remotePath });
+        return {
+            success: true,
+            data: { path: remotePath, size: content.length },
+        };
+    }
+    async deleteFile(remotePath) {
+        const file = this.files.get(remotePath);
+        if (!file) {
+            return { success: false, error: `File not found: ${remotePath}` };
+        }
+        if (file.isDirectory) {
+            return { success: false, error: `Cannot delete directory with delete, use rmdir: ${remotePath}` };
+        }
+        this.files.delete(remotePath);
+        this.logger.info('FTP file deleted', { path: remotePath });
+        return {
+            success: true,
+            data: { path: remotePath, deleted: true },
+        };
+    }
+    async listDirectory(remotePath) {
+        const dir = this.files.get(remotePath);
+        if (!dir) {
+            return { success: false, error: `Directory not found: ${remotePath}` };
+        }
+        if (!dir.isDirectory) {
+            return { success: false, error: `Not a directory: ${remotePath}` };
+        }
+        const prefix = remotePath === '/' ? '/' : remotePath + '/';
+        const files = [];
+        for (const [filePath, file] of this.files.entries()) {
+            if (filePath !== remotePath && filePath.startsWith(prefix)) {
+                const relativePath = filePath.slice(prefix.length);
+                if (!relativePath.includes('/')) {
+                    files.push({
+                        name: relativePath,
+                        path: filePath,
+                        size: file.content.length,
+                        isDirectory: file.isDirectory,
+                        modifiedAt: file.modifiedAt.toISOString(),
+                    });
+                }
+            }
+        }
+        return {
+            success: true,
+            data: { path: remotePath, files },
+        };
+    }
+    async makeDirectory(remotePath) {
+        if (this.files.has(remotePath)) {
+            return { success: false, error: `Path already exists: ${remotePath}` };
+        }
+        const parentPath = this.getParentPath(remotePath);
+        if (parentPath !== '/' && !this.files.has(parentPath)) {
+            return { success: false, error: `Parent directory does not exist: ${parentPath}` };
+        }
+        this.files.set(remotePath, {
+            content: '',
+            isDirectory: true,
+            modifiedAt: new Date(),
+        });
+        this.logger.info('FTP directory created', { path: remotePath });
+        return {
+            success: true,
+            data: { path: remotePath, created: true },
+        };
+    }
+    async removeDirectory(remotePath) {
+        if (remotePath === '/') {
+            return { success: false, error: 'Cannot remove root directory' };
+        }
+        const dir = this.files.get(remotePath);
+        if (!dir) {
+            return { success: false, error: `Directory not found: ${remotePath}` };
+        }
+        if (!dir.isDirectory) {
+            return { success: false, error: `Not a directory: ${remotePath}` };
+        }
+        // Check if empty
+        const prefix = remotePath + '/';
+        for (const path of this.files.keys()) {
+            if (path.startsWith(prefix)) {
+                return { success: false, error: `Directory not empty: ${remotePath}` };
+            }
+        }
+        this.files.delete(remotePath);
+        this.logger.info('FTP directory removed', { path: remotePath });
+        return {
+            success: true,
+            data: { path: remotePath, removed: true },
+        };
+    }
+    async renameFile(oldPath, newPath) {
+        const file = this.files.get(oldPath);
+        if (!file) {
+            return { success: false, error: `File not found: ${oldPath}` };
+        }
+        if (this.files.has(newPath)) {
+            return { success: false, error: `Destination already exists: ${newPath}` };
+        }
+        this.files.set(newPath, file);
+        this.files.delete(oldPath);
+        this.logger.info('FTP file renamed', { oldPath, newPath });
+        return {
+            success: true,
+            data: { oldPath, newPath, renamed: true },
+        };
+    }
+    async exists(remotePath) {
+        return {
+            success: true,
+            data: { path: remotePath, exists: this.files.has(remotePath) },
+        };
+    }
+    // Test helpers
+    getFiles() {
+        return new Map(this.files);
+    }
+    clearFiles() {
+        this.files.clear();
+        this.files.set('/', { content: '', isDirectory: true, modifiedAt: new Date() });
+    }
+    isConnected() {
+        return this.connected;
+    }
+}
+exports.FTPTool = FTPTool;
+//# sourceMappingURL=FileSystemTool.js.map