protoagent 0.0.1

package/dist/tools/write-file.js

@@ -0,0 +1,136 @@
+import fs from 'fs/promises';
+import path from 'path';
+import { randomBytes } from 'crypto';
+import { requestFileOperationApproval } from '../utils/file-operations-approval.js';
+import { logger } from '../utils/logger.js';
+// 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 writeFile(filePath, content) {
+    try {
+        const validPath = await validatePath(filePath);
+        // Check if file already exists for approval context
+        let fileExists = false;
+        try {
+            await fs.access(validPath);
+            fileExists = true;
+        }
+        catch {
+            // File doesn't exist, which is expected for write operations
+        }
+        // Request user approval for write operation
+        const approvalContext = {
+            operation: 'write',
+            filePath: filePath,
+            description: fileExists
+                ? `Overwrite existing file with ${content.length} characters of new content`
+                : `Create new file with ${content.length} characters of content`,
+            contentPreview: content.length > 500
+                ? `${content.substring(0, 250)}...\n\n...${content.substring(content.length - 250)}`
+                : content
+        };
+        const approved = await requestFileOperationApproval(approvalContext);
+        if (!approved) {
+            return `Write operation cancelled by user: ${filePath}`;
+        }
+        logger.debug(`📝 Writing file: ${filePath} (${content.length} chars)`, { component: 'WriteFile', operation: 'writeFile' });
+        try {
+            // Security: 'wx' flag ensures exclusive creation - fails if file/symlink exists,
+            // preventing writes through pre-existing symlinks
+            await fs.writeFile(validPath, content, { encoding: "utf-8", flag: 'wx' });
+            logger.info(`✅ Created new file: ${filePath}`, { component: 'WriteFile', operation: 'writeFile' });
+        }
+        catch (error) {
+            if (error.code === 'EEXIST') {
+                // Security: Use atomic rename to prevent race conditions where symlinks
+                // could be created between validation and write. Rename operations
+                // replace the target file atomically and don't follow symlinks.
+                const tempPath = `${validPath}.${randomBytes(16).toString('hex')}.tmp`;
+                try {
+                    await fs.writeFile(tempPath, content, 'utf-8');
+                    await fs.rename(tempPath, validPath);
+                    logger.info(`✅ Overwrote existing file: ${filePath}`, { component: 'WriteFile', operation: 'writeFile' });
+                }
+                catch (renameError) {
+                    try {
+                        await fs.unlink(tempPath);
+                    }
+                    catch { }
+                    throw renameError;
+                }
+            }
+            else {
+                throw error;
+            }
+        }
+        return `Successfully wrote to ${filePath}`;
+    }
+    catch (error) {
+        if (error instanceof Error) {
+            throw new Error(`Failed to write file: ${error.message}`);
+        }
+        throw new Error('Failed to write file: Unknown error');
+    }
+}
+// Tool definition
+export const writeFileTool = {
+    type: 'function',
+    function: {
+        name: 'write_file',
+        description: 'Create a new file or completely overwrite an existing file with new content. Use this when you need to create new files or update existing ones. The file will be created in the current working directory or subdirectories.',
+        parameters: {
+            type: 'object',
+            properties: {
+                file_path: {
+                    type: 'string',
+                    description: 'The path to the file to write, relative to the current working directory. Examples: "src/newfile.ts", "config.json", "README.md"'
+                },
+                content: {
+                    type: 'string',
+                    description: 'The content to write to the file. This will completely replace any existing content.'
+                }
+            },
+            required: ['file_path', 'content']
+        }
+    }
+};

package/dist/tools.js

@@ -0,0 +1,2 @@
+// Re-export everything from the tools directory
+export * from './tools/index.js';

package/dist/utils/conversation-compactor.js

@@ -0,0 +1,139 @@
+/**
+ * Conversation history compaction utilities
+ */
+/**
+ * Provides the system prompt for the history compression process.
+ * This prompt instructs the model to act as a specialized state manager,
+ * think in a scratchpad, and produce a structured XML summary.
+ */
+export function getCompressionPrompt() {
+    return `
+You are the component that summarizes internal chat history into a given structure.
+
+When the conversation history grows too large, you will be invoked to distill the entire history into a concise, structured XML snapshot. This snapshot is CRITICAL, as it will become the agent's *only* memory of the past. The agent will resume its work based solely on this snapshot. All crucial details, plans, errors, and user directives MUST be preserved.
+
+First, you will think through the entire history in a private <scratchpad>. Review the user's overall goal, the agent's actions, tool outputs, file modifications, and any unresolved questions. Identify every piece of information that is essential for future actions.
+
+After your reasoning is complete, generate the final <state_snapshot> XML object. Be incredibly dense with information. Omit any irrelevant conversational filler.
+
+The structure MUST be as follows:
+
+<state_snapshot>
+    <overall_goal>
+        <!-- A single, concise sentence describing the user's high-level objective. -->
+        <!-- Example: "Refactor the authentication service to use a new JWT library." -->
+    </overall_goal>
+
+    <key_knowledge>
+        <!-- Crucial facts, conventions, and constraints the agent must remember based on the conversation history and interaction with the user. Use bullet points. -->
+        <!-- Example:
+         - Build Command: \`npm run build\`
+         - Testing: Tests are run with \`npm test\`. Test files must end in \`.test.ts\`.
+         - API Endpoint: The primary API endpoint is \`https://api.example.com/v2\`.
+         
+        -->
+    </key_knowledge>
+
+    <file_system_state>
+        <!-- List files that have been created, read, modified, or deleted. Note their status and critical learnings. -->
+        <!-- Example:
+         - CWD: \`/home/user/project/src\`
+         - READ: \`package.json\` - Confirmed 'axios' is a dependency.
+         - MODIFIED: \`services/auth.ts\` - Replaced 'jsonwebtoken' with 'jose'.
+         - CREATED: \`tests/new-feature.test.ts\` - Initial test structure for the new feature.
+        -->
+    </file_system_state>
+
+    <recent_actions>
+        <!-- A summary of the last few significant agent actions and their outcomes. Focus on facts. -->
+        <!-- Example:
+         - Ran \`grep 'old_function'\` which returned 3 results in 2 files.
+         - Ran \`npm run test\`, which failed due to a snapshot mismatch in \`UserProfile.test.ts\`.
+         - Ran \`ls -F static/\` and discovered image assets are stored as \`.webp\`.
+        -->
+    </recent_actions>
+
+    <current_plan>
+        <!-- The agent's step-by-step plan. Mark completed steps. -->
+        <!-- Example:
+         1. [DONE] Identify all files using the deprecated 'UserAPI'.
+         2. [IN PROGRESS] Refactor \`src/components/UserProfile.tsx\` to use the new 'ProfileAPI'.
+         3. [TODO] Refactor the remaining files.
+         4. [TODO] Update tests to reflect the API change.
+        -->
+    </current_plan>
+</state_snapshot>
+`.trim();
+}
+/**
+ * Compact conversation history by creating a summary
+ */
+export async function compactConversation(client, model, messages, recentMessagesToKeep = 5) {
+    console.log('\n🗜️  Compacting conversation history to manage context window...');
+    // Keep the system message and recent messages
+    const systemMessage = messages.find(m => m.role === 'system');
+    const recentMessages = messages.slice(-recentMessagesToKeep);
+    // Get the history to compress (excluding system and recent messages)
+    const historyToCompress = messages.slice(systemMessage ? 1 : 0, -recentMessagesToKeep);
+    if (historyToCompress.length === 0) {
+        console.log('   No history to compress, keeping current messages');
+        return messages;
+    }
+    try {
+        // Create compression request
+        const compressionMessages = [
+            {
+                role: 'system',
+                content: getCompressionPrompt()
+            },
+            {
+                role: 'user',
+                content: `Please compress the following conversation history:\n\n${JSON.stringify(historyToCompress, null, 2)}`
+            }
+        ];
+        // Get compression summary (non-streaming for simplicity)
+        const response = await client.chat.completions.create({
+            model,
+            messages: compressionMessages,
+            max_tokens: 2000,
+            temperature: 0.1
+        });
+        const compressionSummary = response.choices[0]?.message?.content;
+        if (!compressionSummary) {
+            console.log('   Failed to generate compression summary, keeping original messages');
+            return messages;
+        }
+        // Create the compressed history message
+        const compressedMessage = {
+            role: 'system',
+            content: `Previous conversation summary:\n\n${compressionSummary}`
+        };
+        // Build new message array
+        const compactedMessages = [];
+        // Add original system message if it exists
+        if (systemMessage) {
+            compactedMessages.push(systemMessage);
+        }
+        // Add the compressed history
+        compactedMessages.push(compressedMessage);
+        // Add recent messages
+        compactedMessages.push(...recentMessages);
+        console.log(`   ✅ Compressed ${historyToCompress.length} messages into summary`);
+        console.log(`   📝 Keeping ${recentMessages.length} recent messages`);
+        return compactedMessages;
+    }
+    catch (error) {
+        console.log(`   ❌ Compression failed: ${error}. Keeping original messages.`);
+        return messages;
+    }
+}
+/**
+ * Check if conversation needs compaction and perform it if necessary
+ */
+export async function checkAndCompactIfNeeded(client, model, messages, maxTokens, currentTokens) {
+    const utilizationPercentage = (currentTokens / maxTokens) * 100;
+    if (utilizationPercentage >= 90) {
+        return await compactConversation(client, model, messages);
+    }
+    return messages;
+}

package/dist/utils/cost-tracker.js

@@ -0,0 +1,106 @@
+/**
+ * Cost tracking and token counting utilities
+ */
+/**
+ * Rough token estimation for OpenAI models
+ * This is approximate - actual tokenization may vary
+ */
+export function estimateTokens(text) {
+    if (!text)
+        return 0;
+    // Rough estimation: ~4 characters per token for English text
+    // This is conservative and should be close enough for cost estimation
+    return Math.ceil(text.length / 4);
+}
+/**
+ * Estimate tokens for a message
+ */
+export function estimateMessageTokens(message) {
+    let tokens = 0;
+    // Base overhead per message
+    tokens += 4;
+    if ('content' in message && message.content) {
+        if (typeof message.content === 'string') {
+            tokens += estimateTokens(message.content);
+        }
+    }
+    if ('tool_calls' in message && message.tool_calls) {
+        for (const toolCall of message.tool_calls) {
+            tokens += estimateTokens(toolCall.function.name);
+            tokens += estimateTokens(toolCall.function.arguments);
+            tokens += 10; // overhead per tool call
+        }
+    }
+    return tokens;
+}
+/**
+ * Estimate total tokens for conversation history
+ */
+export function estimateConversationTokens(messages) {
+    let totalTokens = 0;
+    for (const message of messages) {
+        totalTokens += estimateMessageTokens(message);
+    }
+    // Add some overhead for the conversation structure
+    totalTokens += 10;
+    return totalTokens;
+}
+/**
+ * Calculate estimated cost for a request
+ */
+export function calculateCost(inputTokens, outputTokens, modelConfig) {
+    const inputCost = inputTokens * modelConfig.pricing.inputTokens;
+    const outputCost = outputTokens * modelConfig.pricing.outputTokens;
+    return inputCost + outputCost;
+}
+/**
+ * Get context information for the current conversation
+ */
+export function getContextInfo(messages, modelConfig) {
+    const currentTokens = estimateConversationTokens(messages);
+    const maxTokens = modelConfig.contextWindow;
+    const utilizationPercentage = (currentTokens / maxTokens) * 100;
+    const needsCompaction = utilizationPercentage >= 90; // Compact at 90% capacity
+    return {
+        currentTokens,
+        maxTokens,
+        utilizationPercentage,
+        needsCompaction
+    };
+}
+/**
+ * Log usage and cost information
+ */
+export function logUsageInfo(usage, contextInfo, modelConfig) {
+    console.log(`💰 Usage: ${usage.inputTokens} in + ${usage.outputTokens} out = ${usage.totalTokens} tokens`);
+    console.log(`💸 Estimated cost: $${usage.estimatedCost.toFixed(6)}`);
+    console.log(`📊 Context: ${contextInfo.currentTokens}/${contextInfo.maxTokens} tokens (${contextInfo.utilizationPercentage.toFixed(1)}%)`);
+    if (contextInfo.needsCompaction) {
+        console.log(`⚠️  Context approaching limit - automatic compaction will trigger soon`);
+    }
+}
+/**
+ * Create usage info from response tokens
+ */
+export function createUsageInfo(inputTokens, outputTokens, modelConfig) {
+    const totalTokens = inputTokens + outputTokens;
+    const estimatedCost = calculateCost(inputTokens, outputTokens, modelConfig);
+    return {
+        inputTokens,
+        outputTokens,
+        totalTokens,
+        estimatedCost
+    };
+}
+/**
+ * Extract token usage from OpenAI response
+ */
+export function extractTokenUsage(response) {
+    // For streaming responses, we need to estimate
+    // In a real implementation, you might want to sum up the tokens from the stream
+    // For now, we'll use rough estimation
+    return {
+        inputTokens: 0, // Will be estimated separately
+        outputTokens: 0 // Will be estimated separately
+    };
+}

package/dist/utils/file-operations-approval.js

@@ -0,0 +1,163 @@
+/**
+ * File operations approval utility for ProtoAgent
+ * Handles user acceptance for write and edit file operations
+ */
+import inquirer from 'inquirer';
+import { logger } from './logger.js';
+// Global state for approval settings
+let globalConfig = null;
+let dangerouslyAcceptAll = false;
+let approvedOperationsForSession = new Set();
+export function setFileOperationConfig(config) {
+    globalConfig = config;
+}
+export function setDangerouslyAcceptAllFileOps(accept) {
+    dangerouslyAcceptAll = accept;
+    if (accept) {
+        logger.warn('⚠️  DANGER MODE: All file operations will be auto-approved without confirmation!');
+    }
+}
+/**
+ * Request user approval for file write/edit operations
+ */
+export async function requestFileOperationApproval(context) {
+    const { operation, filePath, description, contentPreview } = context;
+    // Check if we should auto-approve
+    if (dangerouslyAcceptAll) {
+        logger.info(`🚀 Auto-approving (--dangerously-accept-all): ${operation} ${filePath}`);
+        return true;
+    }
+    const operationType = operation === 'write' ? 'write_file' : 'edit_file';
+    if (approvedOperationsForSession.has(operationType)) {
+        logger.info(`🚀 Auto-approving (${operationType} approved for session): ${operation} ${filePath}`);
+        return true;
+    }
+    // Show detailed information about the operation
+    console.log(`\n🔐 File Operation Requested: ${operation.toUpperCase()}`);
+    console.log(`📁 File: ${filePath}`);
+    console.log(`📝 Description: ${description}`);
+    if (contentPreview) {
+        console.log(`\n📄 Content Preview:`);
+        const lines = contentPreview.split('\n');
+        if (lines.length > 10) {
+            console.log(lines.slice(0, 5).join('\n'));
+            console.log(`... (${lines.length - 10} more lines) ...`);
+            console.log(lines.slice(-5).join('\n'));
+        }
+        else {
+            console.log(contentPreview);
+        }
+    }
+    // Ask for user approval with enhanced options
+    const { choice } = await inquirer.prompt([
+        {
+            type: 'list',
+            name: 'choice',
+            message: 'Choose your action:',
+            choices: [
+                { name: `1. ✅ Approve this ${operation} operation`, value: 'approve' },
+                { name: `2. ✅ Approve and allow all ${operation} operations for this session`, value: 'approve_session' },
+                { name: '3. ❌ Cancel this operation', value: 'cancel' },
+                { name: '4. 📝 Show more details and decide', value: 'details' }
+            ],
+            default: 'approve'
+        }
+    ]);
+    switch (choice) {
+        case 'approve':
+            logger.info(`✅ User approved: ${operation} ${filePath}`);
+            return true;
+        case 'approve_session':
+            approvedOperationsForSession.add(operationType);
+            logger.info(`🔓 "${operationType}" approved for session - all future ${operation} operations will auto-execute`);
+            logger.info(`✅ User approved: ${operation} ${filePath}`);
+            return true;
+        case 'cancel':
+            logger.info(`❌ User cancelled: ${operation} ${filePath}`);
+            return false;
+        case 'details':
+            await showFileOperationDetails(context);
+            // Recursively ask again after showing details
+            return await requestFileOperationApproval(context);
+        default:
+            logger.info(`❌ User cancelled: ${operation} ${filePath}`);
+            return false;
+    }
+}
+/**
+ * Show detailed information about the file operation
+ */
+async function showFileOperationDetails(context) {
+    const { operation, filePath, description, contentPreview } = context;
+    console.log(`\n📋 Detailed File Operation Information:`);
+    console.log(`━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━`);
+    console.log(`🔧 Operation Type: ${operation.toUpperCase()}`);
+    console.log(`📁 Target File: ${filePath}`);
+    console.log(`📝 Description: ${description}`);
+    console.log(`📂 Working Directory: ${process.cwd()}`);
+    // Show file status
+    try {
+        const fs = await import('fs/promises');
+        const stats = await fs.stat(filePath);
+        console.log(`📊 File exists: YES`);
+        console.log(`📅 Last modified: ${stats.mtime.toLocaleString()}`);
+        console.log(`📏 File size: ${stats.size} bytes`);
+    }
+    catch (error) {
+        console.log(`📊 File exists: NO (will be created)`);
+    }
+    // Show full content if available
+    if (contentPreview) {
+        console.log(`\n📄 Full Content Preview:`);
+        console.log(`━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━`);
+        console.log(contentPreview);
+        console.log(`━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━`);
+    }
+    // Show security information
+    console.log(`\n🔒 Security Information:`);
+    console.log(`• File path is validated and restricted to working directory`);
+    console.log(`• Operation will be performed atomically with backup`);
+    console.log(`• You can undo changes using git if needed`);
+    console.log(`\n💡 Recommendation:`);
+    if (operation === 'write' && contentPreview) {
+        console.log(`• WRITE operation will ${contentPreview.includes('export') ? 'create a new file' : 'replace file content'}`);
+        console.log(`• Consider approving if the content looks correct`);
+    }
+    else if (operation === 'edit') {
+        console.log(`• EDIT operation will make targeted changes to existing file`);
+        console.log(`• Generally safer than write operations`);
+    }
+    await inquirer.prompt([{ type: 'input', name: 'continue', message: 'Press Enter to continue...' }]);
+}
+/**
+ * Get current session approval status
+ */
+export function getSessionApprovalStatus() {
+    return {
+        writeApproved: approvedOperationsForSession.has('write_file'),
+        editApproved: approvedOperationsForSession.has('edit_file'),
+        dangerousMode: dangerouslyAcceptAll
+    };
+}
+/**
+ * Clear session approvals
+ */
+export function clearSessionApprovals() {
+    approvedOperationsForSession.clear();
+    logger.info('🔄 Session approvals cleared');
+}
+/**
+ * Show current approval status
+ */
+export function showApprovalStatus() {
+    const status = getSessionApprovalStatus();
+    console.log('\n📊 Current File Operation Approval Status:');
+    console.log(`━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━`);
+    console.log(`🚀 Dangerous Mode (auto-approve all): ${status.dangerousMode ? '✅ ENABLED' : '❌ Disabled'}`);
+    console.log(`✏️  Edit operations for session: ${status.editApproved ? '✅ Auto-approved' : '❌ Require approval'}`);
+    console.log(`📝 Write operations for session: ${status.writeApproved ? '✅ Auto-approved' : '❌ Require approval'}`);
+    if (status.dangerousMode) {
+        console.log(`\n⚠️  WARNING: Dangerous mode is enabled - all file operations will be auto-approved!`);
+    }
+    console.log(`━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\n`);
+}