@oflow-ai/core 0.1.0

package/dist/tools/list-directory.js

@@ -0,0 +1,94 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ListDirectoryTool = void 0;
+const base_1 = require("./base");
+const fs = __importStar(require("fs/promises"));
+const path = __importStar(require("path"));
+class ListDirectoryTool extends base_1.BaseTool {
+    name = 'list_directory';
+    description = 'Lists the names of files and subdirectories directly within a specified directory path.';
+    parameters = {
+        type: 'object',
+        properties: {
+            path: {
+                type: 'string',
+                description: 'The absolute path to the directory to list'
+            },
+            ignore: {
+                type: 'array',
+                items: { type: 'string' },
+                description: 'List of glob patterns to ignore'
+            }
+        },
+        required: ['path']
+    };
+    async execute(params, options) {
+        this.validateRequired(params, ['path']);
+        const dirPath = params.path;
+        const workingDir = options?.workingDirectory || process.cwd();
+        const resolvedPath = path.isAbsolute(dirPath) ? dirPath : path.join(workingDir, dirPath);
+        try {
+            const entries = await fs.readdir(resolvedPath, { withFileTypes: true });
+            let items = entries.map(entry => {
+                const prefix = entry.isDirectory() ? '📁 ' : '📄 ';
+                return prefix + entry.name;
+            });
+            // Apply ignore patterns if provided
+            if (params.ignore && params.ignore.length > 0) {
+                const ignorePatterns = params.ignore;
+                items = items.filter(item => {
+                    const name = item.substring(2); // Remove prefix
+                    return !ignorePatterns.some(pattern => {
+                        if (pattern.includes('*')) {
+                            const regex = new RegExp(pattern.replace(/\*/g, '.*'));
+                            return regex.test(name);
+                        }
+                        return name === pattern;
+                    });
+                });
+            }
+            if (items.length === 0) {
+                return `Directory ${resolvedPath} is empty.`;
+            }
+            return `Contents of ${resolvedPath}:\n\n${items.join('\n')}`;
+        }
+        catch (error) {
+            return (0, base_1.formatToolError)(error);
+        }
+    }
+}
+exports.ListDirectoryTool = ListDirectoryTool;
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoibGlzdC1kaXJlY3RvcnkuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi9zcmMvdG9vbHMvbGlzdC1kaXJlY3RvcnkudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6Ijs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7O0FBQUEsaUNBQXVFO0FBQ3ZFLGdEQUFrQztBQUNsQywyQ0FBNkI7QUFPN0IsTUFBYSxpQkFBa0IsU0FBUSxlQUE2QjtJQUNsRSxJQUFJLEdBQUcsZ0JBQWdCLENBQUM7SUFDeEIsV0FBVyxHQUFHLHlGQUF5RixDQUFDO0lBQ3hHLFVBQVUsR0FBRztRQUNYLElBQUksRUFBRSxRQUFRO1FBQ2QsVUFBVSxFQUFFO1lBQ1YsSUFBSSxFQUFFO2dCQUNKLElBQUksRUFBRSxRQUFRO2dCQUNkLFdBQVcsRUFBRSw0Q0FBNEM7YUFDMUQ7WUFDRCxNQUFNLEVBQUU7Z0JBQ04sSUFBSSxFQUFFLE9BQU87Z0JBQ2IsS0FBSyxFQUFFLEVBQUUsSUFBSSxFQUFFLFFBQVEsRUFBRTtnQkFDekIsV0FBVyxFQUFFLGlDQUFpQzthQUMvQztTQUNGO1FBQ0QsUUFBUSxFQUFFLENBQUMsTUFBTSxDQUFDO0tBQ25CLENBQUM7SUFFRixLQUFLLENBQUMsT0FBTyxDQUFDLE1BQTJCLEVBQUUsT0FBNEI7UUFDckUsSUFBSSxDQUFDLGdCQUFnQixDQUFDLE1BQU0sRUFBRSxDQUFDLE1BQU0sQ0FBQyxDQUFDLENBQUM7UUFFeEMsTUFBTSxPQUFPLEdBQUcsTUFBTSxDQUFDLElBQUksQ0FBQztRQUM1QixNQUFNLFVBQVUsR0FBRyxPQUFPLEVBQUUsZ0JBQWdCLElBQUksT0FBTyxDQUFDLEdBQUcsRUFBRSxDQUFDO1FBQzlELE1BQU0sWUFBWSxHQUFHLElBQUksQ0FBQyxVQUFVLENBQUMsT0FBTyxDQUFDLENBQUMsQ0FBQyxDQUFDLE9BQU8sQ0FBQyxDQUFDLENBQUMsSUFBSSxDQUFDLElBQUksQ0FBQyxVQUFVLEVBQUUsT0FBTyxDQUFDLENBQUM7UUFFekYsSUFBSSxDQUFDO1lBQ0gsTUFBTSxPQUFPLEdBQUcsTUFBTSxFQUFFLENBQUMsT0FBTyxDQUFDLFlBQVksRUFBRSxFQUFFLGFBQWEsRUFBRSxJQUFJLEVBQUUsQ0FBQyxDQUFDO1lBRXhFLElBQUksS0FBSyxHQUFHLE9BQU8sQ0FBQyxHQUFHLENBQUMsS0FBSyxDQUFDLEVBQUU7Z0JBQzlCLE1BQU0sTUFBTSxHQUFHLEtBQUssQ0FBQyxXQUFXLEVBQUUsQ0FBQyxDQUFDLENBQUMsS0FBSyxDQUFDLENBQUMsQ0FBQyxLQUFLLENBQUM7Z0JBQ25ELE9BQU8sTUFBTSxHQUFHLEtBQUssQ0FBQyxJQUFJLENBQUM7WUFDN0IsQ0FBQyxDQUFDLENBQUM7WUFFSCxvQ0FBb0M7WUFDcEMsSUFBSSxNQUFNLENBQUMsTUFBTSxJQUFJLE1BQU0sQ0FBQyxNQUFNLENBQUMsTUFBTSxHQUFHLENBQUMsRUFBRSxDQUFDO2dCQUM5QyxNQUFNLGNBQWMsR0FBRyxNQUFNLENBQUMsTUFBTSxDQUFDO2dCQUNyQyxLQUFLLEdBQUcsS0FBSyxDQUFDLE1BQU0sQ0FBQyxJQUFJLENBQUMsRUFBRTtvQkFDMUIsTUFBTSxJQUFJLEdBQUcsSUFBSSxDQUFDLFNBQVMsQ0FBQyxDQUFDLENBQUMsQ0FBQyxDQUFDLGdCQUFnQjtvQkFDaEQsT0FBTyxDQUFDLGNBQWMsQ0FBQyxJQUFJLENBQUMsT0FBTyxDQUFDLEVBQUU7d0JBQ3BDLElBQUksT0FBTyxDQUFDLFFBQVEsQ0FBQyxHQUFHLENBQUMsRUFBRSxDQUFDOzRCQUMxQixNQUFNLEtBQUssR0FBRyxJQUFJLE1BQU0sQ0FBQyxPQUFPLENBQUMsT0FBTyxDQUFDLEtBQUssRUFBRSxJQUFJLENBQUMsQ0FBQyxDQUFDOzRCQUN2RCxPQUFPLEtBQUssQ0FBQyxJQUFJLENBQUMsSUFBSSxDQUFDLENBQUM7d0JBQzFCLENBQUM7d0JBQ0QsT0FBTyxJQUFJLEtBQUssT0FBTyxDQUFDO29CQUMxQixDQUFDLENBQUMsQ0FBQztnQkFDTCxDQUFDLENBQUMsQ0FBQztZQUNMLENBQUM7WUFFRCxJQUFJLEtBQUssQ0FBQyxNQUFNLEtBQUssQ0FBQyxFQUFFLENBQUM7Z0JBQ3ZCLE9BQU8sYUFBYSxZQUFZLFlBQVksQ0FBQztZQUMvQyxDQUFDO1lBRUQsT0FBTyxlQUFlLFlBQVksUUFBUSxLQUFLLENBQUMsSUFBSSxDQUFDLElBQUksQ0FBQyxFQUFFLENBQUM7UUFDL0QsQ0FBQztRQUFDLE9BQU8sS0FBSyxFQUFFLENBQUM7WUFDZixPQUFPLElBQUEsc0JBQWUsRUFBQyxLQUFLLENBQUMsQ0FBQztRQUNoQyxDQUFDO0lBQ0gsQ0FBQztDQUNGO0FBMURELDhDQTBEQyIsInNvdXJjZXNDb250ZW50IjpbImltcG9ydCB7IEJhc2VUb29sLCBUb29sRXhlY3V0ZU9wdGlvbnMsIGZvcm1hdFRvb2xFcnJvciB9IGZyb20gJy4vYmFzZSc7XG5pbXBvcnQgKiBhcyBmcyBmcm9tICdmcy9wcm9taXNlcyc7XG5pbXBvcnQgKiBhcyBwYXRoIGZyb20gJ3BhdGgnO1xuXG5pbnRlcmZhY2UgTGlzdERpcmVjdG9yeVBhcmFtcyB7XG4gIHBhdGg6IHN0cmluZztcbiAgaWdub3JlPzogc3RyaW5nW107XG59XG5cbmV4cG9ydCBjbGFzcyBMaXN0RGlyZWN0b3J5VG9vbCBleHRlbmRzIEJhc2VUb29sPExpc3REaXJlY3RvcnlQYXJhbXM+IHtcbiAgbmFtZSA9ICdsaXN0X2RpcmVjdG9yeSc7XG4gIGRlc2NyaXB0aW9uID0gJ0xpc3RzIHRoZSBuYW1lcyBvZiBmaWxlcyBhbmQgc3ViZGlyZWN0b3JpZXMgZGlyZWN0bHkgd2l0aGluIGEgc3BlY2lmaWVkIGRpcmVjdG9yeSBwYXRoLic7XG4gIHBhcmFtZXRlcnMgPSB7XG4gICAgdHlwZTogJ29iamVjdCcsXG4gICAgcHJvcGVydGllczoge1xuICAgICAgcGF0aDoge1xuICAgICAgICB0eXBlOiAnc3RyaW5nJyxcbiAgICAgICAgZGVzY3JpcHRpb246ICdUaGUgYWJzb2x1dGUgcGF0aCB0byB0aGUgZGlyZWN0b3J5IHRvIGxpc3QnXG4gICAgICB9LFxuICAgICAgaWdub3JlOiB7XG4gICAgICAgIHR5cGU6ICdhcnJheScsXG4gICAgICAgIGl0ZW1zOiB7IHR5cGU6ICdzdHJpbmcnIH0sXG4gICAgICAgIGRlc2NyaXB0aW9uOiAnTGlzdCBvZiBnbG9iIHBhdHRlcm5zIHRvIGlnbm9yZSdcbiAgICAgIH1cbiAgICB9LFxuICAgIHJlcXVpcmVkOiBbJ3BhdGgnXVxuICB9O1xuXG4gIGFzeW5jIGV4ZWN1dGUocGFyYW1zOiBMaXN0RGlyZWN0b3J5UGFyYW1zLCBvcHRpb25zPzogVG9vbEV4ZWN1dGVPcHRpb25zKTogUHJvbWlzZTxzdHJpbmc+IHtcbiAgICB0aGlzLnZhbGlkYXRlUmVxdWlyZWQocGFyYW1zLCBbJ3BhdGgnXSk7XG5cbiAgICBjb25zdCBkaXJQYXRoID0gcGFyYW1zLnBhdGg7XG4gICAgY29uc3Qgd29ya2luZ0RpciA9IG9wdGlvbnM/LndvcmtpbmdEaXJlY3RvcnkgfHwgcHJvY2Vzcy5jd2QoKTtcbiAgICBjb25zdCByZXNvbHZlZFBhdGggPSBwYXRoLmlzQWJzb2x1dGUoZGlyUGF0aCkgPyBkaXJQYXRoIDogcGF0aC5qb2luKHdvcmtpbmdEaXIsIGRpclBhdGgpO1xuXG4gICAgdHJ5IHtcbiAgICAgIGNvbnN0IGVudHJpZXMgPSBhd2FpdCBmcy5yZWFkZGlyKHJlc29sdmVkUGF0aCwgeyB3aXRoRmlsZVR5cGVzOiB0cnVlIH0pO1xuICAgICAgXG4gICAgICBsZXQgaXRlbXMgPSBlbnRyaWVzLm1hcChlbnRyeSA9PiB7XG4gICAgICAgIGNvbnN0IHByZWZpeCA9IGVudHJ5LmlzRGlyZWN0b3J5KCkgPyAn8J+TgSAnIDogJ/Cfk4QgJztcbiAgICAgICAgcmV0dXJuIHByZWZpeCArIGVudHJ5Lm5hbWU7XG4gICAgICB9KTtcblxuICAgICAgLy8gQXBwbHkgaWdub3JlIHBhdHRlcm5zIGlmIHByb3ZpZGVkXG4gICAgICBpZiAocGFyYW1zLmlnbm9yZSAmJiBwYXJhbXMuaWdub3JlLmxlbmd0aCA+IDApIHtcbiAgICAgICAgY29uc3QgaWdub3JlUGF0dGVybnMgPSBwYXJhbXMuaWdub3JlO1xuICAgICAgICBpdGVtcyA9IGl0ZW1zLmZpbHRlcihpdGVtID0+IHtcbiAgICAgICAgICBjb25zdCBuYW1lID0gaXRlbS5zdWJzdHJpbmcoMik7IC8vIFJlbW92ZSBwcmVmaXhcbiAgICAgICAgICByZXR1cm4gIWlnbm9yZVBhdHRlcm5zLnNvbWUocGF0dGVybiA9PiB7XG4gICAgICAgICAgICBpZiAocGF0dGVybi5pbmNsdWRlcygnKicpKSB7XG4gICAgICAgICAgICAgIGNvbnN0IHJlZ2V4ID0gbmV3IFJlZ0V4cChwYXR0ZXJuLnJlcGxhY2UoL1xcKi9nLCAnLionKSk7XG4gICAgICAgICAgICAgIHJldHVybiByZWdleC50ZXN0KG5hbWUpO1xuICAgICAgICAgICAgfVxuICAgICAgICAgICAgcmV0dXJuIG5hbWUgPT09IHBhdHRlcm47XG4gICAgICAgICAgfSk7XG4gICAgICAgIH0pO1xuICAgICAgfVxuXG4gICAgICBpZiAoaXRlbXMubGVuZ3RoID09PSAwKSB7XG4gICAgICAgIHJldHVybiBgRGlyZWN0b3J5ICR7cmVzb2x2ZWRQYXRofSBpcyBlbXB0eS5gO1xuICAgICAgfVxuXG4gICAgICByZXR1cm4gYENvbnRlbnRzIG9mICR7cmVzb2x2ZWRQYXRofTpcXG5cXG4ke2l0ZW1zLmpvaW4oJ1xcbicpfWA7XG4gICAgfSBjYXRjaCAoZXJyb3IpIHtcbiAgICAgIHJldHVybiBmb3JtYXRUb29sRXJyb3IoZXJyb3IpO1xuICAgIH1cbiAgfVxufVxuIl19

package/dist/tools/pdf-extract.d.ts

@@ -0,0 +1,32 @@
+import { BaseTool, ToolExecuteOptions } from './base';
+interface PDFExtractParams {
+    file_path: string;
+    pages?: string;
+    extract_images?: boolean;
+}
+export declare class PDFExtractTool extends BaseTool<PDFExtractParams> {
+    name: string;
+    description: string;
+    parameters: {
+        type: string;
+        properties: {
+            file_path: {
+                type: string;
+                description: string;
+            };
+            pages: {
+                type: string;
+                description: string;
+            };
+            extract_images: {
+                type: string;
+                description: string;
+            };
+        };
+        required: string[];
+    };
+    execute(params: PDFExtractParams, options?: ToolExecuteOptions): Promise<string>;
+    private extractSimpleText;
+    private formatBytes;
+}
+export {};

package/dist/tools/pdf-extract.js

@@ -0,0 +1,130 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PDFExtractTool = void 0;
+const base_1 = require("./base");
+const fs = __importStar(require("fs/promises"));
+const path = __importStar(require("path"));
+class PDFExtractTool extends base_1.BaseTool {
+    name = 'pdf_extract';
+    description = 'Extracts text and optionally images from PDF files.';
+    parameters = {
+        type: 'object',
+        properties: {
+            file_path: {
+                type: 'string',
+                description: 'The absolute path to the PDF file'
+            },
+            pages: {
+                type: 'string',
+                description: 'Pages to extract (e.g., "1-5" or "1,3,5")'
+            },
+            extract_images: {
+                type: 'boolean',
+                description: 'Whether to extract images from the PDF'
+            }
+        },
+        required: ['file_path']
+    };
+    async execute(params, options) {
+        this.validateRequired(params, ['file_path']);
+        const workingDir = options?.workingDirectory || process.cwd();
+        const filePath = path.isAbsolute(params.file_path)
+            ? params.file_path
+            : path.join(workingDir, params.file_path);
+        try {
+            // 检查文件是否存在
+            const stats = await fs.stat(filePath);
+            if (!stats.isFile()) {
+                return `Error: ${filePath} is not a file`;
+            }
+            // 检查文件扩展名
+            const ext = path.extname(filePath).toLowerCase();
+            if (ext !== '.pdf') {
+                return `Error: ${filePath} is not a PDF file`;
+            }
+            // 读取PDF文件头
+            const buffer = await fs.readFile(filePath);
+            const header = buffer.slice(0, 8).toString();
+            if (!header.startsWith('%PDF')) {
+                return `Error: ${filePath} is not a valid PDF file`;
+            }
+            // 简单的PDF信息提取（实际项目中应使用专门的PDF库）
+            const fileSize = stats.size;
+            const textContent = await this.extractSimpleText(buffer);
+            let result = `PDF File: ${filePath}
+Size: ${this.formatBytes(fileSize)}
+Pages: Not determined (requires PDF parsing library)
+
+Extracted Text Preview:
+${textContent.substring(0, 5000)}${textContent.length > 5000 ? '\n... [truncated]' : ''}`;
+            if (params.extract_images) {
+                result += '\n\nNote: Image extraction requires additional libraries (pdf2pic, pdf-poppler, etc.)';
+            }
+            return result;
+        }
+        catch (error) {
+            return (0, base_1.formatToolError)(error);
+        }
+    }
+    async extractSimpleText(buffer) {
+        // 非常简单的PDF文本提取（仅用于演示）
+        // 实际项目中应使用 pdf-parse 或类似的库
+        let text = '';
+        const content = buffer.toString('binary');
+        // 查找文本流
+        const streamRegex = /stream\r?\n([\s\S]*?)\r?\nendstream/g;
+        let match;
+        while ((match = streamRegex.exec(content)) !== null) {
+            const stream = match[1];
+            // 尝试提取可打印字符
+            const printable = stream.replace(/[^\x20-\x7E\n\r\t]/g, '');
+            if (printable.length > 10) {
+                text += printable + '\n';
+            }
+        }
+        return text || 'No extractable text found (PDF may be scanned or encrypted)';
+    }
+    formatBytes(bytes) {
+        if (bytes === 0)
+            return '0 Bytes';
+        const k = 1024;
+        const sizes = ['Bytes', 'KB', 'MB', 'GB'];
+        const i = Math.floor(Math.log(bytes) / Math.log(k));
+        return parseFloat((bytes / Math.pow(k, i)).toFixed(2)) + ' ' + sizes[i];
+    }
+}
+exports.PDFExtractTool = PDFExtractTool;
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"pdf-extract.js","sourceRoot":"","sources":["../../src/tools/pdf-extract.ts"],"names":[],"mappings":"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","sourcesContent":["import { BaseTool, ToolExecuteOptions, formatToolError } from './base';\nimport * as fs from 'fs/promises';\nimport * as path from 'path';\n\ninterface PDFExtractParams {\n  file_path: string;\n  pages?: string; // e.g., \"1-5\" or \"1,3,5\"\n  extract_images?: boolean;\n}\n\nexport class PDFExtractTool extends BaseTool<PDFExtractParams> {\n  name = 'pdf_extract';\n  description = 'Extracts text and optionally images from PDF files.';\n  parameters = {\n    type: 'object',\n    properties: {\n      file_path: {\n        type: 'string',\n        description: 'The absolute path to the PDF file'\n      },\n      pages: {\n        type: 'string',\n        description: 'Pages to extract (e.g., \"1-5\" or \"1,3,5\")'\n      },\n      extract_images: {\n        type: 'boolean',\n        description: 'Whether to extract images from the PDF'\n      }\n    },\n    required: ['file_path']\n  };\n\n  async execute(params: PDFExtractParams, options?: ToolExecuteOptions): Promise<string> {\n    this.validateRequired(params, ['file_path']);\n\n    const workingDir = options?.workingDirectory || process.cwd();\n    const filePath = path.isAbsolute(params.file_path) \n      ? params.file_path \n      : path.join(workingDir, params.file_path);\n\n    try {\n      // 检查文件是否存在\n      const stats = await fs.stat(filePath);\n      if (!stats.isFile()) {\n        return `Error: ${filePath} is not a file`;\n      }\n\n      // 检查文件扩展名\n      const ext = path.extname(filePath).toLowerCase();\n      if (ext !== '.pdf') {\n        return `Error: ${filePath} is not a PDF file`;\n      }\n\n      // 读取PDF文件头\n      const buffer = await fs.readFile(filePath);\n      const header = buffer.slice(0, 8).toString();\n      \n      if (!header.startsWith('%PDF')) {\n        return `Error: ${filePath} is not a valid PDF file`;\n      }\n\n      // 简单的PDF信息提取（实际项目中应使用专门的PDF库）\n      const fileSize = stats.size;\n      const textContent = await this.extractSimpleText(buffer);\n\n      let result = `PDF File: ${filePath}\nSize: ${this.formatBytes(fileSize)}\nPages: Not determined (requires PDF parsing library)\n\nExtracted Text Preview:\n${textContent.substring(0, 5000)}${textContent.length > 5000 ? '\\n... [truncated]' : ''}`;\n\n      if (params.extract_images) {\n        result += '\\n\\nNote: Image extraction requires additional libraries (pdf2pic, pdf-poppler, etc.)';\n      }\n\n      return result;\n\n    } catch (error) {\n      return formatToolError(error);\n    }\n  }\n\n  private async extractSimpleText(buffer: Buffer): Promise<string> {\n    // 非常简单的PDF文本提取（仅用于演示）\n    // 实际项目中应使用 pdf-parse 或类似的库\n    let text = '';\n    const content = buffer.toString('binary');\n    \n    // 查找文本流\n    const streamRegex = /stream\\r?\\n([\\s\\S]*?)\\r?\\nendstream/g;\n    let match;\n    \n    while ((match = streamRegex.exec(content)) !== null) {\n      const stream = match[1];\n      // 尝试提取可打印字符\n      const printable = stream.replace(/[^\\x20-\\x7E\\n\\r\\t]/g, '');\n      if (printable.length > 10) {\n        text += printable + '\\n';\n      }\n    }\n\n    return text || 'No extractable text found (PDF may be scanned or encrypted)';\n  }\n\n  private formatBytes(bytes: number): string {\n    if (bytes === 0) return '0 Bytes';\n    const k = 1024;\n    const sizes = ['Bytes', 'KB', 'MB', 'GB'];\n    const i = Math.floor(Math.log(bytes) / Math.log(k));\n    return parseFloat((bytes / Math.pow(k, i)).toFixed(2)) + ' ' + sizes[i];\n  }\n}\n"]}

package/dist/tools/read-file.d.ts

@@ -0,0 +1,31 @@
+import { BaseTool, ToolExecuteOptions } from './base';
+interface ReadFileParams {
+    absolute_path: string;
+    offset?: number;
+    limit?: number;
+}
+export declare class ReadFileTool extends BaseTool<ReadFileParams> {
+    name: string;
+    description: string;
+    parameters: {
+        type: string;
+        properties: {
+            absolute_path: {
+                type: string;
+                description: string;
+            };
+            offset: {
+                type: string;
+                description: string;
+            };
+            limit: {
+                type: string;
+                description: string;
+            };
+        };
+        required: string[];
+    };
+    execute(params: ReadFileParams, options?: ToolExecuteOptions): Promise<string>;
+    private getMimeType;
+}
+export {};

package/dist/tools/read-file.js

@@ -0,0 +1,116 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ReadFileTool = void 0;
+const base_1 = require("./base");
+const fs = __importStar(require("fs/promises"));
+const path = __importStar(require("path"));
+class ReadFileTool extends base_1.BaseTool {
+    name = 'read_file';
+    description = 'Reads and returns the content of a specified file from the local filesystem. Handles text files, images, PDF files, and more. For text files, it can read specific line ranges.';
+    parameters = {
+        type: 'object',
+        properties: {
+            absolute_path: {
+                type: 'string',
+                description: 'The absolute path to the file to read'
+            },
+            offset: {
+                type: 'number',
+                description: 'Optional: For text files, the 0-based line number to start reading from'
+            },
+            limit: {
+                type: 'number',
+                description: 'Optional: For text files, maximum number of lines to read'
+            }
+        },
+        required: ['absolute_path']
+    };
+    async execute(params, options) {
+        this.validateRequired(params, ['absolute_path']);
+        const filePath = params.absolute_path;
+        const workingDir = options?.workingDirectory || process.cwd();
+        const resolvedPath = path.isAbsolute(filePath) ? filePath : path.join(workingDir, filePath);
+        try {
+            const stats = await fs.stat(resolvedPath);
+            if (stats.isDirectory()) {
+                return `Error: ${resolvedPath} is a directory, not a file. Use list_directory instead.`;
+            }
+            // Check file type
+            const ext = path.extname(resolvedPath).toLowerCase();
+            const imageExts = ['.png', '.jpg', '.jpeg', '.gif', '.webp', '.svg', '.bmp'];
+            if (imageExts.includes(ext)) {
+                // For images, return base64 info
+                const buffer = await fs.readFile(resolvedPath);
+                const base64 = buffer.toString('base64');
+                const mimeType = this.getMimeType(ext);
+                return `Image file: ${resolvedPath}\nBase64 data: data:${mimeType};base64,${base64.substring(0, 100)}...\n[Base64 data too long to display, use image_read tool for full content]`;
+            }
+            // Read as text
+            const content = await fs.readFile(resolvedPath, 'utf-8');
+            const lines = content.split('\n');
+            if (params.offset !== undefined || params.limit !== undefined) {
+                const offset = params.offset || 0;
+                const limit = params.limit || lines.length - offset;
+                const selectedLines = lines.slice(offset, offset + limit);
+                return selectedLines.join('\n');
+            }
+            // Limit output for very large files
+            if (content.length > 100000) {
+                const truncatedLines = lines.slice(0, 500);
+                return truncatedLines.join('\n') +
+                    `\n\n... [File truncated, showing first 500 lines of ${lines.length} total lines]`;
+            }
+            return content;
+        }
+        catch (error) {
+            return (0, base_1.formatToolError)(error);
+        }
+    }
+    getMimeType(ext) {
+        const mimeTypes = {
+            '.png': 'image/png',
+            '.jpg': 'image/jpeg',
+            '.jpeg': 'image/jpeg',
+            '.gif': 'image/gif',
+            '.webp': 'image/webp',
+            '.svg': 'image/svg+xml',
+            '.bmp': 'image/bmp'
+        };
+        return mimeTypes[ext] || 'application/octet-stream';
+    }
+}
+exports.ReadFileTool = ReadFileTool;
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"read-file.js","sourceRoot":"","sources":["../../src/tools/read-file.ts"],"names":[],"mappings":"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","sourcesContent":["import { BaseTool, ToolExecuteOptions, formatToolError } from './base';\nimport * as fs from 'fs/promises';\nimport * as path from 'path';\n\ninterface ReadFileParams {\n  absolute_path: string;\n  offset?: number;\n  limit?: number;\n}\n\nexport class ReadFileTool extends BaseTool<ReadFileParams> {\n  name = 'read_file';\n  description = 'Reads and returns the content of a specified file from the local filesystem. Handles text files, images, PDF files, and more. For text files, it can read specific line ranges.';\n  parameters = {\n    type: 'object',\n    properties: {\n      absolute_path: {\n        type: 'string',\n        description: 'The absolute path to the file to read'\n      },\n      offset: {\n        type: 'number',\n        description: 'Optional: For text files, the 0-based line number to start reading from'\n      },\n      limit: {\n        type: 'number',\n        description: 'Optional: For text files, maximum number of lines to read'\n      }\n    },\n    required: ['absolute_path']\n  };\n\n  async execute(params: ReadFileParams, options?: ToolExecuteOptions): Promise<string> {\n    this.validateRequired(params, ['absolute_path']);\n\n    const filePath = params.absolute_path;\n    const workingDir = options?.workingDirectory || process.cwd();\n    const resolvedPath = path.isAbsolute(filePath) ? filePath : path.join(workingDir, filePath);\n\n    try {\n      const stats = await fs.stat(resolvedPath);\n      \n      if (stats.isDirectory()) {\n        return `Error: ${resolvedPath} is a directory, not a file. Use list_directory instead.`;\n      }\n\n      // Check file type\n      const ext = path.extname(resolvedPath).toLowerCase();\n      const imageExts = ['.png', '.jpg', '.jpeg', '.gif', '.webp', '.svg', '.bmp'];\n      \n      if (imageExts.includes(ext)) {\n        // For images, return base64 info\n        const buffer = await fs.readFile(resolvedPath);\n        const base64 = buffer.toString('base64');\n        const mimeType = this.getMimeType(ext);\n        return `Image file: ${resolvedPath}\\nBase64 data: data:${mimeType};base64,${base64.substring(0, 100)}...\\n[Base64 data too long to display, use image_read tool for full content]`;\n      }\n\n      // Read as text\n      const content = await fs.readFile(resolvedPath, 'utf-8');\n      const lines = content.split('\\n');\n\n      if (params.offset !== undefined || params.limit !== undefined) {\n        const offset = params.offset || 0;\n        const limit = params.limit || lines.length - offset;\n        const selectedLines = lines.slice(offset, offset + limit);\n        return selectedLines.join('\\n');\n      }\n\n      // Limit output for very large files\n      if (content.length > 100000) {\n        const truncatedLines = lines.slice(0, 500);\n        return truncatedLines.join('\\n') + \n          `\\n\\n... [File truncated, showing first 500 lines of ${lines.length} total lines]`;\n      }\n\n      return content;\n    } catch (error) {\n      return formatToolError(error);\n    }\n  }\n\n  private getMimeType(ext: string): string {\n    const mimeTypes: Record<string, string> = {\n      '.png': 'image/png',\n      '.jpg': 'image/jpeg',\n      '.jpeg': 'image/jpeg',\n      '.gif': 'image/gif',\n      '.webp': 'image/webp',\n      '.svg': 'image/svg+xml',\n      '.bmp': 'image/bmp'\n    };\n    return mimeTypes[ext] || 'application/octet-stream';\n  }\n}\n"]}

package/dist/tools/replace.d.ts

@@ -0,0 +1,35 @@
+import { BaseTool, ToolExecuteOptions } from './base';
+interface ReplaceParams {
+    file_path: string;
+    old_string: string;
+    new_string: string;
+    instruction?: string;
+}
+export declare class ReplaceTool extends BaseTool<ReplaceParams> {
+    name: string;
+    description: string;
+    parameters: {
+        type: string;
+        properties: {
+            file_path: {
+                type: string;
+                description: string;
+            };
+            old_string: {
+                type: string;
+                description: string;
+            };
+            new_string: {
+                type: string;
+                description: string;
+            };
+            instruction: {
+                type: string;
+                description: string;
+            };
+        };
+        required: string[];
+    };
+    execute(params: ReplaceParams, options?: ToolExecuteOptions): Promise<string>;
+}
+export {};

package/dist/tools/replace.js

@@ -0,0 +1,93 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ReplaceTool = void 0;
+const base_1 = require("./base");
+const fs = __importStar(require("fs/promises"));
+const path = __importStar(require("path"));
+class ReplaceTool extends base_1.BaseTool {
+    name = 'replace';
+    description = 'Replaces text within a file. Requires exact matching of the old_string.';
+    parameters = {
+        type: 'object',
+        properties: {
+            file_path: {
+                type: 'string',
+                description: 'The absolute path to the file to modify'
+            },
+            old_string: {
+                type: 'string',
+                description: 'The exact literal text to replace'
+            },
+            new_string: {
+                type: 'string',
+                description: 'The exact literal text to replace with'
+            },
+            instruction: {
+                type: 'string',
+                description: 'Detailed instruction of what needs to be changed'
+            }
+        },
+        required: ['file_path', 'old_string', 'new_string']
+    };
+    async execute(params, options) {
+        this.validateRequired(params, ['file_path', 'old_string', 'new_string']);
+        const workingDir = options?.workingDirectory || process.cwd();
+        const filePath = path.isAbsolute(params.file_path)
+            ? params.file_path
+            : path.join(workingDir, params.file_path);
+        try {
+            const content = await fs.readFile(filePath, 'utf-8');
+            // Check if old_string exists
+            if (!content.includes(params.old_string)) {
+                return `Error: The old_string was not found in ${filePath}. Please read the file first to ensure exact matching.`;
+            }
+            // Check for multiple occurrences
+            const occurrences = content.split(params.old_string).length - 1;
+            if (occurrences > 1) {
+                return `Error: Found ${occurrences} occurrences of old_string. The old_string must uniquely identify a single instance. Please include more context to make it unique.`;
+            }
+            // Perform replacement
+            const newContent = content.replace(params.old_string, params.new_string);
+            await fs.writeFile(filePath, newContent, 'utf-8');
+            return `Successfully replaced text in ${filePath}`;
+        }
+        catch (error) {
+            return (0, base_1.formatToolError)(error);
+        }
+    }
+}
+exports.ReplaceTool = ReplaceTool;
+//# sourceMappingURL=data:application/json;base64,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

package/dist/tools/run-shell-command.d.ts

@@ -0,0 +1,35 @@
+import { BaseTool, ToolExecuteOptions } from './base';
+interface RunShellCommandParams {
+    command: string;
+    description?: string;
+    timeout?: number;
+    run_in_bg?: boolean;
+}
+export declare class RunShellCommandTool extends BaseTool<RunShellCommandParams> {
+    name: string;
+    description: string;
+    parameters: {
+        type: string;
+        properties: {
+            command: {
+                type: string;
+                description: string;
+            };
+            description: {
+                type: string;
+                description: string;
+            };
+            timeout: {
+                type: string;
+                description: string;
+            };
+            run_in_bg: {
+                type: string;
+                description: string;
+            };
+        };
+        required: string[];
+    };
+    execute(params: RunShellCommandParams, options?: ToolExecuteOptions): Promise<string>;
+}
+export {};