protoagent 0.0.5 → 0.1.0

package/dist/tools/read-file.js

@@ -1,111 +1,67 @@
-import fs from 'fs/promises';
-import path from 'path';
-// Configuration constants
-const DEFAULT_READ_LIMIT = 2000;
-const MAX_LINE_LENGTH = 2000;
-// Current working directory for file operations
-const workingDirectory = process.cwd();
-// Security utilities
-function normalizePath(p) {
-    return path.normalize(p);
-}
-async function validatePath(requestedPath) {
-    const absolute = path.isAbsolute(requestedPath)
-        ? path.resolve(requestedPath)
-        : path.resolve(workingDirectory, requestedPath);
-    const normalizedRequested = normalizePath(absolute);
-    // Check if path is within working directory
-    if (!normalizedRequested.startsWith(workingDirectory)) {
-        throw new Error(`Access denied - path outside working directory: ${absolute}`);
-    }
-    // Handle symlinks by checking their real path
-    try {
-        const realPath = await fs.realpath(absolute);
-        const normalizedReal = normalizePath(realPath);
-        if (!normalizedReal.startsWith(workingDirectory)) {
-            throw new Error(`Access denied - symlink target outside working directory: ${realPath}`);
-        }
-        return realPath;
-    }
-    catch (error) {
-        // For new files that don't exist yet, verify parent directory
-        if (error.code === 'ENOENT') {
-            const parentDir = path.dirname(absolute);
-            try {
-                const realParentPath = await fs.realpath(parentDir);
-                const normalizedParent = normalizePath(realParentPath);
-                if (!normalizedParent.startsWith(workingDirectory)) {
-                    throw new Error(`Access denied - parent directory outside working directory: ${realParentPath}`);
-                }
-                return absolute;
-            }
-            catch {
-                throw new Error(`Parent directory does not exist: ${parentDir}`);
-            }
-        }
-        throw error;
-    }
-}
-export async function readFile(filePath, offset, limit) {
-    try {
-        const validPath = await validatePath(filePath);
-        // Check if file exists and is actually a file
-        const stats = await fs.stat(validPath);
-        if (!stats.isFile()) {
-            throw new Error('Path is not a file');
-        }
-        // Read and return file content
-        const content = await fs.readFile(validPath, 'utf-8');
-        const lines = content.split('\n');
-        // Apply offset and limit if specified
-        const startLine = offset ? Math.max(0, offset - 1) : 0; // Convert to 0-based indexing
-        const endLine = limit ? Math.min(lines.length, startLine + limit) : Math.min(lines.length, startLine + DEFAULT_READ_LIMIT);
-        // Truncate lines that are too long
-        const processedLines = lines.slice(startLine, endLine).map(line => line.length > MAX_LINE_LENGTH ? line.substring(0, MAX_LINE_LENGTH) + '...[truncated]' : line);
-        const result = processedLines.join('\n');
-        // Add metadata if file was truncated or offset was used
-        let metadata = '';
-        if (offset && offset > 1) {
-            metadata += `\n[File started at line ${offset}]`;
-        }
-        if (endLine < lines.length) {
-            metadata += `\n[File truncated - showing lines ${startLine + 1}-${endLine} of ${lines.length} total lines]`;
-        }
-        if (processedLines.some(line => line.includes('...[truncated]'))) {
-            metadata += `\n[Some lines truncated at ${MAX_LINE_LENGTH} characters]`;
-        }
-        return result + metadata;
-    }
-    catch (error) {
-        if (error instanceof Error) {
-            throw new Error(`Failed to read file: ${error.message}`);
-        }
-        throw new Error('Failed to read file: Unknown error');
-    }
-}
-// Tool definition
+/**
+ * read_file tool — Read file contents with optional offset and limit.
+ */
+import fs from 'node:fs/promises';
+import { createReadStream } from 'node:fs';
+import readline from 'node:readline';
+import { validatePath } from '../utils/path-validation.js';
 export const readFileTool = {
     type: 'function',
     function: {
         name: 'read_file',
-        description: 'Read the contents of a file in the current working directory or its subdirectories. Use this when you need to examine code, configuration files, or any text-based files to help the user. Supports reading specific line ranges for large files.',
+        description: 'Read the contents of a file. Returns the file content with line numbers. Use offset and limit to read specific sections of large files.',
         parameters: {
             type: 'object',
             properties: {
-                file_path: {
-                    type: 'string',
-                    description: 'The path to the file to read, relative to the current working directory. Examples: "src/index.ts", "package.json", "README.md"'
-                },
-                offset: {
-                    type: 'integer',
-                    description: 'Optional: The 1-based line number to start reading from. If not specified, reads from the beginning of the file.'
-                },
-                limit: {
-                    type: 'integer',
-                    description: 'Optional: The maximum number of lines to read. If not specified, reads up to 2000 lines. Use this with offset to read specific sections of large files.'
-                }
+                file_path: { type: 'string', description: 'Path to the file to read (relative to working directory).' },
+                offset: { type: 'number', description: 'Line number to start reading from (0-based). Defaults to 0.' },
+                limit: { type: 'number', description: 'Maximum number of lines to read. Defaults to 2000.' },
             },
-            required: ['file_path']
+            required: ['file_path'],
+        },
+    },
+};
+export async function readFile(filePath, offset = 0, limit = 2000) {
+    const validated = await validatePath(filePath);
+    const start = Math.max(0, offset);
+    const maxLines = Math.max(0, limit);
+    const lines = [];
+    let totalLines = 0;
+    const stream = createReadStream(validated, { encoding: 'utf8' });
+    const lineReader = readline.createInterface({
+        input: stream,
+        crlfDelay: Infinity,
+    });
+    try {
+        for await (const line of lineReader) {
+            if (totalLines >= start && lines.length < maxLines) {
+                lines.push(line);
+            }
+            totalLines++;
+        }
+        const stats = await fs.stat(validated);
+        if (stats.size === 0) {
+            totalLines = 0;
+        }
+        else if (lines.length === 0 && totalLines === 0) {
+            totalLines = 1;
         }
     }
-};
+    finally {
+        lineReader.close();
+        stream.destroy();
+    }
+    const end = Math.min(totalLines, start + lines.length);
+    // Add line numbers (1-based)
+    const numbered = lines.map((line, i) => {
+        const lineNum = String(start + i + 1).padStart(5, ' ');
+        // Truncate very long lines
+        const truncated = line.length > 2000 ? line.slice(0, 2000) + '... (truncated)' : line;
+        return `${lineNum} | ${truncated}`;
+    });
+    const rangeLabel = lines.length === 0
+        ? 'none'
+        : `${Math.min(start + 1, totalLines)}-${end}`;
+    const header = `File: ${filePath} (${totalLines} lines total, showing ${rangeLabel})`;
+    return `${header}\n${numbered.join('\n')}`;
+}

package/dist/tools/search-files.js

@@ -1,177 +1,89 @@
-import fs from 'fs/promises';
-import path from 'path';
-// Current working directory for file operations
-const workingDirectory = process.cwd();
-// Security utilities
-function normalizePath(p) {
-    return path.normalize(p);
-}
-async function validatePath(requestedPath) {
-    const absolute = path.isAbsolute(requestedPath)
-        ? path.resolve(requestedPath)
-        : path.resolve(workingDirectory, requestedPath);
-    const normalizedRequested = normalizePath(absolute);
-    // Check if path is within working directory
-    if (!normalizedRequested.startsWith(workingDirectory)) {
-        throw new Error(`Access denied - path outside working directory: ${absolute}`);
-    }
-    // Handle symlinks by checking their real path
-    try {
-        const realPath = await fs.realpath(absolute);
-        const normalizedReal = normalizePath(realPath);
-        if (!normalizedReal.startsWith(workingDirectory)) {
-            throw new Error(`Access denied - symlink target outside working directory: ${realPath}`);
-        }
-        return realPath;
-    }
-    catch (error) {
-        // For new files that don't exist yet, verify parent directory
-        if (error.code === 'ENOENT') {
-            const parentDir = path.dirname(absolute);
-            try {
-                const realParentPath = await fs.realpath(parentDir);
-                const normalizedParent = normalizePath(realParentPath);
-                if (!normalizedParent.startsWith(workingDirectory)) {
-                    throw new Error(`Access denied - parent directory outside working directory: ${realParentPath}`);
-                }
-                return absolute;
-            }
-            catch {
-                throw new Error(`Parent directory does not exist: ${parentDir}`);
-            }
-        }
-        throw error;
-    }
-}
-// Search utility function
-async function searchInFile(filePath, searchTerm, caseSensitive = false) {
+/**
+ * search_files tool — Recursive text search across files.
+ */
+import fs from 'node:fs/promises';
+import path from 'node:path';
+import { validatePath } from '../utils/path-validation.js';
+export const searchFilesTool = {
+    type: 'function',
+    function: {
+        name: 'search_files',
+        description: 'Search for a text pattern across files in a directory (recursive). Returns matching lines with file paths and line numbers.',
+        parameters: {
+            type: 'object',
+            properties: {
+                search_term: { type: 'string', description: 'The text or regex pattern to search for.' },
+                directory_path: { type: 'string', description: 'Directory to search in. Defaults to ".".' },
+                file_extensions: {
+                    type: 'array',
+                    items: { type: 'string' },
+                    description: 'Filter by file extensions, e.g. [".ts", ".js"]. Searches all files if omitted.',
+                },
+                case_sensitive: { type: 'boolean', description: 'Whether the search is case-sensitive. Defaults to true.' },
+            },
+            required: ['search_term'],
+        },
+    },
+};
+export async function searchFiles(searchTerm, directoryPath = '.', caseSensitive = true, fileExtensions) {
+    const validated = await validatePath(directoryPath);
+    const flags = caseSensitive ? 'g' : 'gi';
+    let regex;
     try {
-        const content = await fs.readFile(filePath, 'utf-8');
-        const lines = content.split('\n');
-        const matchingLines = [];
-        let totalMatches = 0;
-        const searchPattern = caseSensitive ? searchTerm : searchTerm.toLowerCase();
-        lines.forEach((line, index) => {
-            const searchLine = caseSensitive ? line : line.toLowerCase();
-            if (searchLine.includes(searchPattern)) {
-                totalMatches++;
-                matchingLines.push(`${index + 1}: ${line}`);
-            }
-        });
-        return { matches: totalMatches, lines: matchingLines };
+        regex = new RegExp(searchTerm, flags);
     }
     catch (error) {
-        return { matches: 0, lines: [] };
+        const message = error instanceof Error ? error.message : String(error);
+        return `Error: invalid regex pattern "${searchTerm}": ${message}`;
     }
-}
-async function searchInDirectory(dirPath, searchTerm, caseSensitive = false, fileExtensions = []) {
-    const validPath = await validatePath(dirPath);
     const results = [];
-    async function searchRecursive(currentPath, depth = 0) {
-        if (depth > 10)
-            return; // Prevent infinite recursion
-        try {
-            const entries = await fs.readdir(currentPath, { withFileTypes: true });
-            for (const entry of entries) {
-                const fullPath = path.join(currentPath, entry.name);
-                // Skip common directories that should be ignored
-                if (entry.isDirectory() && ['node_modules', '.git', '.DS_Store', 'dist', 'build'].includes(entry.name)) {
+    const MAX_RESULTS = 100;
+    async function search(dir) {
+        if (results.length >= MAX_RESULTS)
+            return;
+        const entries = await fs.readdir(dir, { withFileTypes: true });
+        for (const entry of entries) {
+            if (results.length >= MAX_RESULTS)
+                break;
+            const fullPath = path.join(dir, entry.name);
+            // Skip common non-useful directories
+            if (entry.isDirectory()) {
+                if (['node_modules', '.git', 'dist', 'build', 'coverage', '__pycache__'].includes(entry.name))
                     continue;
-                }
-                if (entry.isDirectory()) {
-                    await searchRecursive(fullPath, depth + 1);
-                }
-                else if (entry.isFile()) {
-                    // Check file extension filter
-                    if (fileExtensions.length > 0) {
-                        const ext = path.extname(entry.name).toLowerCase();
-                        if (!fileExtensions.includes(ext)) {
-                            continue;
-                        }
-                    }
-                    try {
-                        const searchResult = await searchInFile(fullPath, searchTerm, caseSensitive);
-                        if (searchResult.matches > 0) {
-                            const relativePath = path.relative(workingDirectory, fullPath);
-                            results.push(`\n📁 ${relativePath} (${searchResult.matches} matches):`);
-                            results.push(...searchResult.lines.map(line => `  ${line}`));
+                await search(fullPath);
+                continue;
+            }
+            // Filter by extension
+            if (fileExtensions && fileExtensions.length > 0) {
+                const ext = path.extname(entry.name);
+                if (!fileExtensions.includes(ext))
+                    continue;
+            }
+            try {
+                const content = await fs.readFile(fullPath, 'utf8');
+                const lines = content.split('\n');
+                for (let i = 0; i < lines.length && results.length < MAX_RESULTS; i++) {
+                    if (regex.test(lines[i])) {
+                        const relativePath = path.relative(validated, fullPath);
+                        let lineContent = lines[i].trim();
+                        // Truncate long lines
+                        if (lineContent.length > 500) {
+                            lineContent = lineContent.slice(0, 500) + '... (truncated)';
                         }
+                        results.push(`${relativePath}:${i + 1}: ${lineContent}`);
                     }
-                    catch (error) {
-                        // Skip files we can't read
-                    }
+                    regex.lastIndex = 0; // reset regex state
                 }
             }
-        }
-        catch (error) {
-            // Skip directories we can't read
+            catch {
+                // Skip files we can't read (binary, permission issues)
+            }
         }
     }
-    await searchRecursive(validPath);
+    await search(validated);
     if (results.length === 0) {
-        return `No matches found for "${searchTerm}" in ${dirPath}`;
-    }
-    return results.join('\n');
-}
-export async function searchFiles(searchTerm, dirPath = '.', caseSensitive = false, fileExtensions = []) {
-    try {
-        if (!searchTerm.trim()) {
-            throw new Error('Search term cannot be empty');
-        }
-        const validPath = await validatePath(dirPath);
-        // Check if path exists and is a directory
-        const stats = await fs.stat(validPath);
-        if (!stats.isDirectory()) {
-            throw new Error('Search path must be a directory');
-        }
-        const results = await searchInDirectory(validPath, searchTerm, caseSensitive, fileExtensions);
-        const searchInfo = [
-            `🔍 Searching for: "${searchTerm}"`,
-            `📂 In directory: ${path.relative(workingDirectory, validPath) || '.'}`,
-            `📝 Case sensitive: ${caseSensitive ? 'Yes' : 'No'}`,
-            fileExtensions.length > 0 ? `🎯 File types: ${fileExtensions.join(', ')}` : '🎯 All file types',
-            '',
-        ].join('\n');
-        return searchInfo + results;
-    }
-    catch (error) {
-        if (error instanceof Error) {
-            throw new Error(`Failed to search files: ${error.message}`);
-        }
-        throw new Error('Failed to search files: Unknown error');
+        return `No matches found for "${searchTerm}" in ${directoryPath}`;
     }
+    const suffix = results.length >= MAX_RESULTS ? `\n(results truncated at ${MAX_RESULTS})` : '';
+    return `Found ${results.length} match(es) for "${searchTerm}":\n${results.join('\n')}${suffix}`;
 }
-// Tool definition
-export const searchFilesTool = {
-    type: 'function',
-    function: {
-        name: 'search_files',
-        description: 'Search for a text string within files in a directory. Supports case sensitivity and file type filtering. Returns the list of files and matching lines. Use this to find specific code, configuration settings, or documentation within your project files.',
-        parameters: {
-            type: 'object',
-            properties: {
-                search_term: {
-                    type: 'string',
-                    description: 'The text string to search for within files.'
-                },
-                directory_path: {
-                    type: 'string',
-                    description: 'The directory to search within, relative to the current working directory. Use "." for the current directory.'
-                },
-                case_sensitive: {
-                    type: 'boolean',
-                    description: 'Whether the search should be case sensitive.'
-                },
-                file_extensions: {
-                    type: 'array',
-                    items: {
-                        type: 'string',
-                        description: 'File extension to include in the search (e.g., "js", "txt"). Leave empty to search all file types.'
-                    },
-                    description: 'List of file extensions to include in the search.'
-                }
-            },
-            required: ['search_term', 'directory_path']
-        }
-    }
-};

package/dist/tools/todo.js

@@ -1,177 +1,94 @@
 /**
- * Todo management tool for ProtoAgent
+ * todo_read / todo_write tools - in-memory task tracking.
+ *
+ * The agent uses these to plan multi-step work and track progress.
+ * Todos are stored per session. The active session can also persist them
+ * through the session store.
  */
-import { z } from 'zod';
-// Define the todo item schema
-const TodoItemSchema = z.object({
-    id: z.string().describe('Unique identifier for the todo item'),
-    content: z.string().describe('Brief description of the task'),
-    status: z.enum(['pending', 'in_progress', 'completed', 'cancelled']).describe('Current status of the task'),
-    priority: z.enum(['high', 'medium', 'low']).describe('Priority level of the task'),
-    created: z.string().optional().describe('Creation timestamp'),
-    updated: z.string().optional().describe('Last update timestamp')
-});
-// In-memory storage for todo items (could be persisted to file later)
-const todoStorage = {};
-/**
- * Get current session ID (simplified - could use actual session management)
- */
-function getCurrentSessionId() {
-    return 'default_session';
+const DEFAULT_SESSION_ID = '__default__';
+// Session-scoped in-memory storage
+const todosBySession = new Map();
+function getSessionKey(sessionId) {
+    return sessionId ?? DEFAULT_SESSION_ID;
 }
-/**
- * Generate a unique ID for todo items
- */
-function generateTodoId() {
-    return `todo_${Date.now()}_${Math.random().toString(36).substring(2, 9)}`;
+function cloneTodos(todos) {
+    return todos.map((todo) => ({ ...todo }));
+}
+function formatTodos(todos, heading) {
+    if (todos.length === 0) {
+        return `${heading}\nNo TODOs.`;
+    }
+    const statusIcons = {
+        pending: '[ ]',
+        in_progress: '[~]',
+        completed: '[x]',
+        cancelled: '[-]',
+    };
+    const lines = todos.map((t) => `${statusIcons[t.status]} [${t.priority}] ${t.content} (${t.id})`);
+    return `${heading}\n${lines.join('\n')}`;
 }
-/**
- * Tool for reading the current todo list
- */
 export const todoReadTool = {
     type: 'function',
     function: {
         name: 'todo_read',
-        description: 'Read the current todo list to see all tasks and their status',
+        description: 'Read the current TODO list to check progress on tasks.',
         parameters: {
             type: 'object',
             properties: {},
-            required: []
-        }
-    }
+            required: [],
+        },
+    },
 };
-/**
- * Tool for writing/updating the todo list
- */
 export const todoWriteTool = {
     type: 'function',
     function: {
         name: 'todo_write',
-        description: 'Update the todo list by providing a complete list of todos with their current status. Use this to add new todos, update existing ones, or mark items as completed.',
+        description: 'Replace the TODO list with an updated version. Use this to plan tasks, update progress, and mark items complete.',
         parameters: {
             type: 'object',
             properties: {
                 todos: {
                     type: 'array',
-                    description: 'The complete updated todo list',
+                    description: 'The complete updated TODO list.',
                     items: {
                         type: 'object',
                         properties: {
-                            id: {
-                                type: 'string',
-                                description: 'Unique identifier for the todo item. Use existing ID to update, or provide new ID for new items.'
-                            },
-                            content: {
-                                type: 'string',
-                                description: 'Brief description of the task'
-                            },
+                            id: { type: 'string', description: 'Unique identifier for the item.' },
+                            content: { type: 'string', description: 'Description of the task.' },
                             status: {
                                 type: 'string',
                                 enum: ['pending', 'in_progress', 'completed', 'cancelled'],
-                                description: 'Current status of the task'
+                                description: 'Current status.',
                             },
                             priority: {
                                 type: 'string',
                                 enum: ['high', 'medium', 'low'],
-                                description: 'Priority level of the task'
-                            }
+                                description: 'Priority level.',
+                            },
                         },
-                        required: ['id', 'content', 'status', 'priority']
-                    }
-                }
+                        required: ['id', 'content', 'status', 'priority'],
+                    },
+                },
             },
-            required: ['todos']
-        }
-    }
+            required: ['todos'],
+        },
+    },
 };
-/**
- * Handle todo read operation
- */
-export async function handleTodoRead() {
-    const sessionId = getCurrentSessionId();
-    const todos = todoStorage[sessionId] || [];
-    if (todos.length === 0) {
-        return 'Todo list is empty. No tasks found.';
-    }
-    const activeTodos = todos.filter(t => t.status !== 'completed');
-    const completedTodos = todos.filter(t => t.status === 'completed');
-    let result = `Todo List (${activeTodos.length} active, ${completedTodos.length} completed):\n\n`;
-    // Show active todos first
-    if (activeTodos.length > 0) {
-        result += '📋 ACTIVE TASKS:\n';
-        activeTodos.forEach((todo, index) => {
-            const priorityIcon = todo.priority === 'high' ? '🔴' : todo.priority === 'medium' ? '🟡' : '🟢';
-            const statusIcon = todo.status === 'in_progress' ? '🔄' : '⏳';
-            result += `${index + 1}. ${statusIcon} ${priorityIcon} ${todo.content} [${todo.status.toUpperCase()}]\n`;
-            result += `   ID: ${todo.id}\n\n`;
-        });
-    }
-    // Show completed todos
-    if (completedTodos.length > 0) {
-        result += '✅ COMPLETED TASKS:\n';
-        completedTodos.forEach((todo, index) => {
-            result += `${index + 1}. ✅ ${todo.content}\n`;
-            result += `   ID: ${todo.id}\n\n`;
-        });
-    }
-    return result.trim();
+export function readTodos(sessionId) {
+    const todos = todosBySession.get(getSessionKey(sessionId)) ?? [];
+    return formatTodos(todos, `TODO List (${todos.length} items):`);
 }
-/**
- * Handle todo write operation
- */
-export async function handleTodoWrite(todos) {
-    const sessionId = getCurrentSessionId();
-    try {
-        // Validate and process todos
-        const validatedTodos = [];
-        const timestamp = new Date().toISOString();
-        for (const todo of todos) {
-            // Parse and validate each todo item
-            const parsed = TodoItemSchema.parse({
-                ...todo,
-                updated: timestamp,
-                created: todo.created || timestamp
-            });
-            validatedTodos.push(parsed);
-        }
-        // Update storage
-        todoStorage[sessionId] = validatedTodos;
-        // Generate summary
-        const activeTodos = validatedTodos.filter(t => t.status !== 'completed');
-        const completedTodos = validatedTodos.filter(t => t.status === 'completed');
-        const highPriorityTodos = activeTodos.filter(t => t.priority === 'high');
-        let result = `✅ Todo list updated successfully!\n\n`;
-        result += `📊 Summary:\n`;
-        result += `- Total tasks: ${validatedTodos.length}\n`;
-        result += `- Active tasks: ${activeTodos.length}\n`;
-        result += `- Completed tasks: ${completedTodos.length}\n`;
-        result += `- High priority tasks: ${highPriorityTodos.length}\n\n`;
-        if (highPriorityTodos.length > 0) {
-            result += `🔴 HIGH PRIORITY TASKS:\n`;
-            highPriorityTodos.forEach((todo, index) => {
-                const statusIcon = todo.status === 'in_progress' ? '🔄' : '⏳';
-                result += `${index + 1}. ${statusIcon} ${todo.content}\n`;
-            });
-        }
-        return result.trim();
-    }
-    catch (error) {
-        return `❌ Error updating todo list: ${error instanceof Error ? error.message : 'Unknown error'}`;
-    }
+export function writeTodos(newTodos, sessionId) {
+    const todos = cloneTodos(newTodos);
+    todosBySession.set(getSessionKey(sessionId), todos);
+    return formatTodos(todos, `TODO List Updated (${todos.length} items):`);
 }
-/**
- * Main todo tool handler
- */
-export async function handleTodoTool(toolName, args) {
-    switch (toolName) {
-        case 'todo_read':
-            return await handleTodoRead();
-        case 'todo_write':
-            if (!args.todos || !Array.isArray(args.todos)) {
-                return '❌ Error: todos parameter must be an array';
-            }
-            return await handleTodoWrite(args.todos);
-        default:
-            return `❌ Unknown todo tool: ${toolName}`;
-    }
+export function getTodosForSession(sessionId) {
+    return cloneTodos(todosBySession.get(getSessionKey(sessionId)) ?? []);
+}
+export function setTodosForSession(sessionId, todos) {
+    todosBySession.set(getSessionKey(sessionId), cloneTodos(todos));
+}
+export function clearTodos(sessionId) {
+    todosBySession.delete(getSessionKey(sessionId));
 }