scorpion-cli 0.1.0

package/src/tools/documents.js

@@ -0,0 +1,299 @@
+/**
+ * Document Tools
+ * Create summaries, reports, and documents
+ */
+
+import fs from 'fs/promises';
+import path from 'path';
+
+// Tool: save_report
+export const saveReport = {
+    schema: {
+        type: 'function',
+        function: {
+            name: 'save_report',
+            description: 'Save a report or document to a file. Use this to create text files, markdown documents, or reports with structured content.',
+            parameters: {
+                type: 'object',
+                required: ['title', 'content', 'path'],
+                properties: {
+                    title: {
+                        type: 'string',
+                        description: 'Title of the report'
+                    },
+                    content: {
+                        type: 'string',
+                        description: 'Main content of the report'
+                    },
+                    path: {
+                        type: 'string',
+                        description: 'File path to save the report (e.g., "report.txt" or "C:/Users/Amaan/report.md")'
+                    },
+                    format: {
+                        type: 'string',
+                        enum: ['txt', 'md'],
+                        description: 'Output format (default: based on file extension)'
+                    },
+                    include_timestamp: {
+                        type: 'boolean',
+                        description: 'Include generation timestamp (default: true)'
+                    }
+                }
+            }
+        }
+    },
+    execute: async ({ title, content, path: filePath, format, include_timestamp = true }) => {
+        try {
+            const absolutePath = path.resolve(filePath);
+            const ext = format || path.extname(absolutePath).slice(1) || 'txt';
+            const isMarkdown = ext === 'md';
+
+            let fileContent = '';
+
+            if (isMarkdown) {
+                fileContent = `# ${title}\n\n`;
+                if (include_timestamp) {
+                    fileContent += `*Generated: ${new Date().toLocaleString()}*\n\n---\n\n`;
+                }
+                fileContent += content;
+            } else {
+                fileContent = `${title}\n${'='.repeat(title.length)}\n\n`;
+                if (include_timestamp) {
+                    fileContent += `Generated: ${new Date().toLocaleString()}\n\n`;
+                }
+                fileContent += content;
+            }
+
+            await fs.mkdir(path.dirname(absolutePath), { recursive: true });
+            await fs.writeFile(absolutePath, fileContent, 'utf-8');
+
+            const stats = await fs.stat(absolutePath);
+
+            return JSON.stringify({
+                success: true,
+                path: absolutePath,
+                title,
+                format: ext,
+                size: formatBytes(stats.size),
+                message: `Report saved successfully to ${absolutePath}`
+            });
+        } catch (error) {
+            return JSON.stringify({ success: false, error: error.message });
+        }
+    }
+};
+
+// Tool: create_summary
+export const createSummary = {
+    schema: {
+        type: 'function',
+        function: {
+            name: 'create_summary',
+            description: 'Format content as a structured summary. Returns formatted text that can be displayed or saved.',
+            parameters: {
+                type: 'object',
+                required: ['content'],
+                properties: {
+                    content: {
+                        type: 'string',
+                        description: 'Content to summarize/format'
+                    },
+                    format: {
+                        type: 'string',
+                        enum: ['text', 'markdown', 'bullets'],
+                        description: 'Output format (default: text)'
+                    },
+                    title: {
+                        type: 'string',
+                        description: 'Optional title for the summary'
+                    }
+                }
+            }
+        }
+    },
+    execute: async ({ content, format = 'text', title }) => {
+        try {
+            let formatted = '';
+
+            switch (format) {
+                case 'markdown':
+                    if (title) {
+                        formatted = `## ${title}\n\n${content}`;
+                    } else {
+                        formatted = content;
+                    }
+                    break;
+
+                case 'bullets':
+                    const lines = content.split('\n').filter(l => l.trim());
+                    if (title) {
+                        formatted = `${title}:\n`;
+                    }
+                    formatted += lines.map(l => `• ${l.trim()}`).join('\n');
+                    break;
+
+                case 'text':
+                default:
+                    if (title) {
+                        formatted = `${title}\n${'-'.repeat(title.length)}\n\n${content}`;
+                    } else {
+                        formatted = content;
+                    }
+                    break;
+            }
+
+            return JSON.stringify({
+                success: true,
+                format,
+                summary: formatted,
+                characterCount: formatted.length
+            });
+        } catch (error) {
+            return JSON.stringify({ success: false, error: error.message });
+        }
+    }
+};
+
+// Tool: create_table
+export const createTable = {
+    schema: {
+        type: 'function',
+        function: {
+            name: 'create_table',
+            description: 'Create a formatted table from data. Useful for presenting structured information.',
+            parameters: {
+                type: 'object',
+                required: ['headers', 'rows'],
+                properties: {
+                    headers: {
+                        type: 'array',
+                        items: { type: 'string' },
+                        description: 'Column headers'
+                    },
+                    rows: {
+                        type: 'array',
+                        items: {
+                            type: 'array',
+                            items: { type: 'string' }
+                        },
+                        description: 'Data rows (array of arrays)'
+                    },
+                    format: {
+                        type: 'string',
+                        enum: ['markdown', 'text'],
+                        description: 'Output format (default: markdown)'
+                    }
+                }
+            }
+        }
+    },
+    execute: async ({ headers, rows, format = 'markdown' }) => {
+        try {
+            let table = '';
+
+            if (format === 'markdown') {
+                // Markdown table
+                table = '| ' + headers.join(' | ') + ' |\n';
+                table += '| ' + headers.map(() => '---').join(' | ') + ' |\n';
+                for (const row of rows) {
+                    table += '| ' + row.join(' | ') + ' |\n';
+                }
+            } else {
+                // Text table
+                const widths = headers.map((h, i) => {
+                    const maxRowWidth = Math.max(...rows.map(r => String(r[i] || '').length));
+                    return Math.max(h.length, maxRowWidth);
+                });
+
+                const separator = '+' + widths.map(w => '-'.repeat(w + 2)).join('+') + '+';
+
+                table = separator + '\n';
+                table += '| ' + headers.map((h, i) => h.padEnd(widths[i])).join(' | ') + ' |\n';
+                table += separator + '\n';
+
+                for (const row of rows) {
+                    table += '| ' + row.map((c, i) => String(c || '').padEnd(widths[i])).join(' | ') + ' |\n';
+                }
+                table += separator;
+            }
+
+            return JSON.stringify({
+                success: true,
+                format,
+                table,
+                rowCount: rows.length,
+                columnCount: headers.length
+            });
+        } catch (error) {
+            return JSON.stringify({ success: false, error: error.message });
+        }
+    }
+};
+
+// Tool: append_to_document
+export const appendToDocument = {
+    schema: {
+        type: 'function',
+        function: {
+            name: 'append_to_document',
+            description: 'Append content to an existing document or create it if it does not exist.',
+            parameters: {
+                type: 'object',
+                required: ['path', 'content'],
+                properties: {
+                    path: {
+                        type: 'string',
+                        description: 'Path to the document'
+                    },
+                    content: {
+                        type: 'string',
+                        description: 'Content to append'
+                    },
+                    add_separator: {
+                        type: 'boolean',
+                        description: 'Add a separator line before the content (default: true)'
+                    }
+                }
+            }
+        }
+    },
+    execute: async ({ path: filePath, content, add_separator = true }) => {
+        try {
+            const absolutePath = path.resolve(filePath);
+
+            let existingContent = '';
+            try {
+                existingContent = await fs.readFile(absolutePath, 'utf-8');
+            } catch (e) {
+                // File doesn't exist, will be created
+            }
+
+            let newContent = content;
+            if (existingContent && add_separator) {
+                newContent = '\n\n---\n\n' + content;
+            } else if (existingContent) {
+                newContent = '\n\n' + content;
+            }
+
+            await fs.appendFile(absolutePath, newContent, 'utf-8');
+
+            return JSON.stringify({
+                success: true,
+                path: absolutePath,
+                message: existingContent ? 'Content appended' : 'Document created',
+                appendedLength: newContent.length
+            });
+        } catch (error) {
+            return JSON.stringify({ success: false, error: error.message });
+        }
+    }
+};
+
+// Helper function
+function formatBytes(bytes) {
+    if (bytes === 0) return '0 B';
+    const k = 1024;
+    const sizes = ['B', 'KB', 'MB', 'GB'];
+    const i = Math.floor(Math.log(bytes) / Math.log(k));
+    return parseFloat((bytes / Math.pow(k, i)).toFixed(2)) + ' ' + sizes[i];
+}

package/src/tools/filesystem.js

@@ -0,0 +1,402 @@
+/**
+ * Filesystem Tools
+ * File and directory operations
+ */
+
+import fs from 'fs/promises';
+import path from 'path';
+import { glob } from 'fs/promises';
+
+// Tool: create_file
+export const createFile = {
+    schema: {
+        type: 'function',
+        function: {
+            name: 'create_file',
+            description: 'Create a new file with the specified content. Creates parent directories if they do not exist.',
+            parameters: {
+                type: 'object',
+                required: ['path', 'content'],
+                properties: {
+                    path: {
+                        type: 'string',
+                        description: 'Absolute or relative path for the new file'
+                    },
+                    content: {
+                        type: 'string',
+                        description: 'Content to write to the file'
+                    }
+                }
+            }
+        }
+    },
+    execute: async ({ path: filePath, content }) => {
+        try {
+            const absolutePath = path.resolve(filePath);
+            await fs.mkdir(path.dirname(absolutePath), { recursive: true });
+            await fs.writeFile(absolutePath, content, 'utf-8');
+
+            return JSON.stringify({
+                success: true,
+                path: absolutePath,
+                message: `File created successfully at ${absolutePath}`
+            });
+        } catch (error) {
+            return JSON.stringify({ success: false, error: error.message });
+        }
+    }
+};
+
+// Tool: read_file
+export const readFile = {
+    schema: {
+        type: 'function',
+        function: {
+            name: 'read_file',
+            description: 'Read the contents of a file',
+            parameters: {
+                type: 'object',
+                required: ['path'],
+                properties: {
+                    path: {
+                        type: 'string',
+                        description: 'Path to the file to read'
+                    },
+                    encoding: {
+                        type: 'string',
+                        description: 'File encoding (default: utf-8)'
+                    }
+                }
+            }
+        }
+    },
+    execute: async ({ path: filePath, encoding = 'utf-8' }) => {
+        try {
+            const absolutePath = path.resolve(filePath);
+            const content = await fs.readFile(absolutePath, encoding);
+            const stats = await fs.stat(absolutePath);
+
+            return JSON.stringify({
+                success: true,
+                path: absolutePath,
+                content,
+                size: stats.size,
+                modified: stats.mtime.toISOString()
+            });
+        } catch (error) {
+            return JSON.stringify({ success: false, error: error.message });
+        }
+    }
+};
+
+// Tool: write_file
+export const writeFile = {
+    schema: {
+        type: 'function',
+        function: {
+            name: 'write_file',
+            description: 'Write or append content to a file',
+            parameters: {
+                type: 'object',
+                required: ['path', 'content'],
+                properties: {
+                    path: {
+                        type: 'string',
+                        description: 'Path to the file'
+                    },
+                    content: {
+                        type: 'string',
+                        description: 'Content to write'
+                    },
+                    append: {
+                        type: 'boolean',
+                        description: 'If true, append to file instead of overwriting (default: false)'
+                    }
+                }
+            }
+        }
+    },
+    execute: async ({ path: filePath, content, append = false }) => {
+        try {
+            const absolutePath = path.resolve(filePath);
+
+            if (append) {
+                await fs.appendFile(absolutePath, content, 'utf-8');
+            } else {
+                await fs.writeFile(absolutePath, content, 'utf-8');
+            }
+
+            return JSON.stringify({
+                success: true,
+                path: absolutePath,
+                message: append ? 'Content appended' : 'File written'
+            });
+        } catch (error) {
+            return JSON.stringify({ success: false, error: error.message });
+        }
+    }
+};
+
+// Tool: list_directory
+export const listDirectory = {
+    schema: {
+        type: 'function',
+        function: {
+            name: 'list_directory',
+            description: 'List contents of a directory with file information',
+            parameters: {
+                type: 'object',
+                required: ['path'],
+                properties: {
+                    path: {
+                        type: 'string',
+                        description: 'Directory path to list'
+                    },
+                    recursive: {
+                        type: 'boolean',
+                        description: 'If true, list recursively (default: false)'
+                    },
+                    limit: {
+                        type: 'integer',
+                        description: 'Maximum number of items to return (default: 100)'
+                    }
+                }
+            }
+        }
+    },
+    execute: async ({ path: dirPath, recursive = false, limit = 100 }) => {
+        try {
+            const absolutePath = path.resolve(dirPath);
+            const items = [];
+
+            async function listDir(dir, depth = 0) {
+                if (items.length >= limit) return;
+
+                const entries = await fs.readdir(dir, { withFileTypes: true });
+
+                for (const entry of entries) {
+                    if (items.length >= limit) break;
+
+                    const fullPath = path.join(dir, entry.name);
+                    const relativePath = path.relative(absolutePath, fullPath);
+
+                    try {
+                        const stats = await fs.stat(fullPath);
+                        items.push({
+                            name: entry.name,
+                            path: relativePath || entry.name,
+                            type: entry.isDirectory() ? 'directory' : 'file',
+                            size: entry.isFile() ? stats.size : undefined,
+                            modified: stats.mtime.toISOString()
+                        });
+
+                        if (recursive && entry.isDirectory() && depth < 5) {
+                            await listDir(fullPath, depth + 1);
+                        }
+                    } catch (e) {
+                        // Skip inaccessible items
+                    }
+                }
+            }
+
+            await listDir(absolutePath);
+
+            return JSON.stringify({
+                success: true,
+                path: absolutePath,
+                count: items.length,
+                truncated: items.length >= limit,
+                items
+            });
+        } catch (error) {
+            return JSON.stringify({ success: false, error: error.message });
+        }
+    }
+};
+
+// Tool: search_files
+export const searchFiles = {
+    schema: {
+        type: 'function',
+        function: {
+            name: 'search_files',
+            description: 'Search for files by name pattern in a directory',
+            parameters: {
+                type: 'object',
+                required: ['path', 'pattern'],
+                properties: {
+                    path: {
+                        type: 'string',
+                        description: 'Directory to search in'
+                    },
+                    pattern: {
+                        type: 'string',
+                        description: 'Search pattern (e.g., "*.txt", "report*", "**/*.js")'
+                    },
+                    limit: {
+                        type: 'integer',
+                        description: 'Maximum results (default: 50)'
+                    }
+                }
+            }
+        }
+    },
+    execute: async ({ path: searchPath, pattern, limit = 50 }) => {
+        try {
+            const absolutePath = path.resolve(searchPath);
+            const results = [];
+
+            // Simple recursive search
+            async function searchDir(dir) {
+                if (results.length >= limit) return;
+
+                const entries = await fs.readdir(dir, { withFileTypes: true });
+
+                for (const entry of entries) {
+                    if (results.length >= limit) break;
+
+                    const fullPath = path.join(dir, entry.name);
+
+                    // Simple pattern matching
+                    const regex = new RegExp(
+                        pattern
+                            .replace(/\./g, '\\.')
+                            .replace(/\*/g, '.*')
+                            .replace(/\?/g, '.'),
+                        'i'
+                    );
+
+                    if (regex.test(entry.name)) {
+                        try {
+                            const stats = await fs.stat(fullPath);
+                            results.push({
+                                name: entry.name,
+                                path: fullPath,
+                                type: entry.isDirectory() ? 'directory' : 'file',
+                                size: entry.isFile() ? stats.size : undefined
+                            });
+                        } catch (e) {
+                            // Skip inaccessible
+                        }
+                    }
+
+                    if (entry.isDirectory()) {
+                        try {
+                            await searchDir(fullPath);
+                        } catch (e) {
+                            // Skip inaccessible directories
+                        }
+                    }
+                }
+            }
+
+            await searchDir(absolutePath);
+
+            return JSON.stringify({
+                success: true,
+                pattern,
+                searchPath: absolutePath,
+                count: results.length,
+                results
+            });
+        } catch (error) {
+            return JSON.stringify({ success: false, error: error.message });
+        }
+    }
+};
+
+// Tool: delete_file
+export const deleteFile = {
+    schema: {
+        type: 'function',
+        function: {
+            name: 'delete_file',
+            description: 'Delete a file or empty directory',
+            parameters: {
+                type: 'object',
+                required: ['path'],
+                properties: {
+                    path: {
+                        type: 'string',
+                        description: 'Path to the file or directory to delete'
+                    },
+                    recursive: {
+                        type: 'boolean',
+                        description: 'If true, delete directories recursively (use with caution)'
+                    }
+                }
+            }
+        }
+    },
+    execute: async ({ path: targetPath, recursive = false }) => {
+        try {
+            const absolutePath = path.resolve(targetPath);
+            const stats = await fs.stat(absolutePath);
+
+            if (stats.isDirectory()) {
+                await fs.rm(absolutePath, { recursive });
+            } else {
+                await fs.unlink(absolutePath);
+            }
+
+            return JSON.stringify({
+                success: true,
+                path: absolutePath,
+                message: `Deleted ${stats.isDirectory() ? 'directory' : 'file'}: ${absolutePath}`
+            });
+        } catch (error) {
+            return JSON.stringify({ success: false, error: error.message });
+        }
+    }
+};
+
+// Tool: get_file_info
+export const getFileInfo = {
+    schema: {
+        type: 'function',
+        function: {
+            name: 'get_file_info',
+            description: 'Get detailed information about a file or directory',
+            parameters: {
+                type: 'object',
+                required: ['path'],
+                properties: {
+                    path: {
+                        type: 'string',
+                        description: 'Path to the file or directory'
+                    }
+                }
+            }
+        }
+    },
+    execute: async ({ path: targetPath }) => {
+        try {
+            const absolutePath = path.resolve(targetPath);
+            const stats = await fs.stat(absolutePath);
+
+            return JSON.stringify({
+                success: true,
+                path: absolutePath,
+                name: path.basename(absolutePath),
+                type: stats.isDirectory() ? 'directory' : 'file',
+                size: stats.size,
+                sizeFormatted: formatBytes(stats.size),
+                created: stats.birthtime.toISOString(),
+                modified: stats.mtime.toISOString(),
+                accessed: stats.atime.toISOString(),
+                isReadOnly: !(stats.mode & 0o200)
+            });
+        } catch (error) {
+            return JSON.stringify({ success: false, error: error.message });
+        }
+    }
+};
+
+// Helper function
+function formatBytes(bytes) {
+    if (bytes === 0) return '0 B';
+    const k = 1024;
+    const sizes = ['B', 'KB', 'MB', 'GB', 'TB'];
+    const i = Math.floor(Math.log(bytes) / Math.log(k));
+    return parseFloat((bytes / Math.pow(k, i)).toFixed(2)) + ' ' + sizes[i];
+}