coding-agent/dist/tools/file-system.js

An AI coding agent using @agenite framework

import * as fs from 'fs/promises';
import * as path from 'path';
import { Tool } from '@agenite/tool';
export function createFileSystemTool() {
    return new Tool({
        name: 'file_system',
        description: 'Read, write, and check files in the project. Can create both files and directories',
        inputSchema: {
            type: 'object',
            properties: {
                operation: {
                    type: 'string',
                    enum: ['read', 'write', 'list', 'exists', 'mkdir'],
                },
                path: { type: 'string', description: 'relative path to the file' },
                content: {
                    type: 'string',
                    description: 'Content to write to the file',
                },
            },
            required: ['operation', 'path'],
        },
        async execute({ input }) {
            const startTime = Date.now();
            const rootPath = process.cwd() + '/' + 'output';
            const fullPath = rootPath + '/' + input.path;
            try {
                switch (input.operation) {
                    case 'read': {
                        const content = await fs.readFile(fullPath, 'utf-8');
                        return {
                            isError: false,
                            data: content,
                            duration: Date.now() - startTime,
                        };
                    }
                    case 'write': {
                        await fs.mkdir(path.dirname(fullPath), { recursive: true });
                        await fs.writeFile(fullPath, input.content || '');
                        return {
                            isError: false,
                            data: `File written to ${input.path}`,
                            duration: Date.now() - startTime,
                        };
                    }
                    case 'list': {
                        const files = await fs.readdir(fullPath, { recursive: true });
                        return {
                            isError: false,
                            data: files.join('\n'),
                            duration: Date.now() - startTime,
                        };
                    }
                    case 'exists': {
                        try {
                            await fs.access(input.path);
                            return {
                                isError: false,
                                data: 'true',
                                duration: Date.now() - startTime,
                            };
                        }
                        catch {
                            return {
                                isError: false,
                                data: 'false',
                                duration: Date.now() - startTime,
                            };
                        }
                    }
                    case 'mkdir': {
                        await fs.mkdir(fullPath, { recursive: true });
                        return {
                            isError: false,
                            data: `Directory created at ${input.path}`,
                            duration: Date.now() - startTime,
                        };
                    }
                    default:
                        return {
                            isError: true,
                            data: `Unknown operation: ${input.operation}`,
                            duration: Date.now() - startTime,
                        };
                }
            }
            catch (error) {
                return {
                    isError: true,
                    data: error instanceof Error ? `${error.message}` : 'Unknown error',
                    duration: Date.now() - startTime,
                };
            }
        },
    });
}