protoagent 0.0.5 → 0.1.0

package/dist/utils/cost-tracker.js

@@ -1,107 +1,52 @@
 /**
- * Cost tracking and token counting utilities
- */
-import { logger } from './logger.js';
-/**
- * Rough token estimation for OpenAI models
- * This is approximate - actual tokenization may vary
+ * Token estimation and cost tracking.
+ *
+ * Uses a rough heuristic (~4 chars per token) for estimation.
+ * Prefers actual usage data from the API when available.
  */
+/** Rough token estimation: ~4 characters per token. */
 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);
-        }
+/** Estimate tokens for a single message including overhead. */
+export function estimateMessageTokens(msg) {
+    let tokens = 4; // per-message overhead
+    if ('content' in msg && typeof msg.content === 'string') {
+        tokens += estimateTokens(msg.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
+    if ('tool_calls' in msg && Array.isArray(msg.tool_calls)) {
+        for (const tc of msg.tool_calls) {
+            tokens += estimateTokens(tc.function?.name || '') + estimateTokens(tc.function?.arguments || '') + 10;
         }
     }
     return tokens;
 }
-/**
- * Estimate total tokens for conversation history
- */
+/** Estimate total tokens for a conversation. */
 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;
+    return messages.reduce((sum, m) => sum + estimateMessageTokens(m), 0) + 10;
 }
-/**
- * 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;
+/** Calculate dollar cost for a given number of tokens. */
+export function calculateCost(inputTokens, outputTokens, pricing) {
+    return inputTokens * pricing.inputPerToken + outputTokens * pricing.outputPerToken;
 }
-/**
- * Get context information for the current conversation
- */
-export function getContextInfo(messages, modelConfig) {
+/** Get context window utilisation info. */
+export function getContextInfo(messages, pricing) {
     const currentTokens = estimateConversationTokens(messages);
-    const maxTokens = modelConfig.contextWindow;
+    const maxTokens = pricing.contextWindow;
     const utilizationPercentage = (currentTokens / maxTokens) * 100;
-    const needsCompaction = utilizationPercentage >= 90; // Compact at 90% capacity
     return {
         currentTokens,
         maxTokens,
         utilizationPercentage,
-        needsCompaction
+        needsCompaction: utilizationPercentage >= 90,
     };
 }
-/**
- * Log usage and cost information
- */
-export function logUsageInfo(usage, contextInfo, modelConfig) {
-    logger.consoleLog(`💰 Usage: ${usage.inputTokens} in + ${usage.outputTokens} out = ${usage.totalTokens} tokens`);
-    logger.consoleLog(`💸 Estimated cost: $${usage.estimatedCost.toFixed(6)}`);
-    logger.consoleLog(`📊 Context: ${contextInfo.currentTokens}/${contextInfo.maxTokens} tokens (${contextInfo.utilizationPercentage.toFixed(1)}%)`);
-    if (contextInfo.needsCompaction) {
-        logger.consoleLog(`⚠️  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);
+/** Build a UsageInfo from actual or estimated token counts. */
+export function createUsageInfo(inputTokens, outputTokens, pricing) {
     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
+        totalTokens: inputTokens + outputTokens,
+        estimatedCost: calculateCost(inputTokens, outputTokens, pricing),
     };
 }

package/dist/utils/format-message.js

@@ -0,0 +1,26 @@
+/**
+ * Parse Markdown-style formatting and convert to ANSI escape codes.
+ *
+ * Supports:
+ * - **bold** → bold text
+ * - *italic* → italic text
+ * - ***bold italic*** → bold + italic text
+ *
+ * Returns a string with ANSI escape codes that Ink will render with styling.
+ */
+export function formatMessage(text) {
+    // ANSI escape codes for styling
+    const BOLD = '\x1b[1m';
+    const ITALIC = '\x1b[3m';
+    const RESET = '\x1b[0m';
+    let result = text;
+    // Strip markdown hashtags (headers)
+    result = result.replace(/^#+\s+/gm, '');
+    // Replace ***bold italic*** first (to avoid matching ** or * inside)
+    result = result.replace(/\*\*\*(.+?)\*\*\*/g, `${BOLD}${ITALIC}$1${RESET}`);
+    // Replace **bold**
+    result = result.replace(/\*\*(.+?)\*\*/g, `${BOLD}$1${RESET}`);
+    // Replace *italic*
+    result = result.replace(/\*(.+?)\*/g, `${ITALIC}$1${RESET}`);
+    return result;
+}

package/dist/utils/logger.js

@@ -1,9 +1,15 @@
 /**
- * Configurable logging utility for ProtoAgent
+ * Logger utility with configurable log levels.
+ *
+ * Levels (from least to most verbose):
+ *   ERROR (0) → WARN (1) → INFO (2) → DEBUG (3) → TRACE (4)
+ *
+ * Set the level via `setLogLevel()` or the `--log-level` CLI flag.
+ * Logs are written to a file to avoid interfering with Ink UI rendering.
  */
-import fs from 'fs';
-import path from 'path';
-import os from 'os';
+import { appendFileSync, mkdirSync, existsSync } from 'node:fs';
+import { join } from 'node:path';
+import { homedir } from 'node:os';
 export var LogLevel;
 (function (LogLevel) {
     LogLevel[LogLevel["ERROR"] = 0] = "ERROR";
@@ -12,311 +18,99 @@ export var LogLevel;
     LogLevel[LogLevel["DEBUG"] = 3] = "DEBUG";
     LogLevel[LogLevel["TRACE"] = 4] = "TRACE";
 })(LogLevel || (LogLevel = {}));
-export var LogFormat;
-(function (LogFormat) {
-    LogFormat["TEXT"] = "text";
-    LogFormat["JSONL"] = "jsonl";
-})(LogFormat || (LogFormat = {}));
-class Logger {
-    constructor() {
-        this.level = LogLevel.INFO;
-        this.timestamps = true;
-        this.colors = true;
-        this.fileLogging = false;
-        this.logFilePath = '';
-        this.logFormat = LogFormat.TEXT; // Default to readable text format
-        // Initialize with default settings
-    }
-    enableFileLogging(logDir, format) {
-        this.fileLogging = true;
-        if (format) {
-            this.logFormat = format;
-        }
-        // Create log directory
-        const defaultLogDir = path.join(os.homedir(), '.protoagent', 'logs');
-        const targetLogDir = logDir || defaultLogDir;
-        try {
-            fs.mkdirSync(targetLogDir, { recursive: true });
-        }
-        catch (error) {
-            console.error('Failed to create log directory:', error);
-            this.fileLogging = false;
-            return;
-        }
-        // Create unique log file name
-        const timestamp = new Date().toISOString().slice(0, 19).replace(/[:.]/g, '-');
-        const sessionId = Date.now().toString().slice(-6);
-        const extension = this.logFormat === LogFormat.JSONL ? 'jsonl' : 'log';
-        this.logFilePath = path.join(targetLogDir, `protoagent-${timestamp}-${sessionId}.${extension}`);
-        // Write initial log entry
-        this.writeToFile({
-            timestamp: new Date().toISOString(),
-            level: 'INFO',
-            message: `ProtoAgent logging session started`,
-            component: 'Logger',
-            metadata: {
-                logFile: this.logFilePath,
-                version: '0.0.2',
-                format: this.logFormat
-            }
-        });
-        // Output the log file path immediately at the beginning
-        logger.consoleLog(`📝 Log file: ${this.logFilePath}`);
-        // Note: We can't log this to file since we're in the logger itself
-    }
-    disableFileLogging() {
-        if (this.fileLogging) {
-            this.writeToFile({
-                timestamp: new Date().toISOString(),
-                level: 'INFO',
-                message: 'ProtoAgent logging session ended',
-                component: 'Logger'
-            });
-        }
-        this.fileLogging = false;
-    }
-    getLogFilePath() {
-        return this.logFilePath;
-    }
-    writeToFile(entry) {
-        if (!this.fileLogging || !this.logFilePath)
-            return;
-        try {
-            let logLine;
-            if (this.logFormat === LogFormat.JSONL) {
-                // JSON Lines format - one JSON object per line
-                logLine = JSON.stringify({
-                    timestamp: entry.timestamp,
-                    level: entry.level,
-                    message: entry.message,
-                    component: entry.component,
-                    ...entry.metadata // Spread metadata fields to root level
-                });
-            }
-            else {
-                // Traditional text format
-                logLine = this.formatFileLogEntry(entry);
-            }
-            fs.appendFileSync(this.logFilePath, logLine + '\n');
-        }
-        catch (error) {
-            // Fallback to console if file writing fails
-            console.error(`Failed to write to log file: ${error}`);
-            this.fileLogging = false;
-        }
-    }
-    formatFileLogEntry(entry) {
-        const { timestamp, level, message, component, metadata } = entry;
-        let formatted = `[${timestamp}] ${level.padEnd(5)} `;
-        if (component) {
-            formatted += `[${component}] `;
-        }
-        formatted += message;
-        if (metadata && Object.keys(metadata).length > 0) {
-            formatted += ` | ${JSON.stringify(metadata)}`;
-        }
-        return formatted;
-    }
-    setLevel(level) {
-        this.level = level;
-        this.debug(`🔍 Log level set to: ${LogLevel[level]}`);
-    }
-    getLevel() {
-        return this.level;
-    }
-    setTimestamps(enabled) {
-        this.timestamps = enabled;
-    }
-    setColors(enabled) {
-        this.colors = enabled;
-    }
-    formatMessage(level, message, context) {
-        let formatted = message;
-        if (this.timestamps) {
-            const timestamp = new Date().toISOString().slice(11, 23); // HH:MM:SS.mmm
-            formatted = `[${timestamp}] ${formatted}`;
-        }
-        if (context) {
-            const contextParts = [];
-            if (context.component)
-                contextParts.push(`${context.component}`);
-            if (context.operation)
-                contextParts.push(`${context.operation}`);
-            if (context.duration !== undefined)
-                contextParts.push(`${context.duration}ms`);
-            if (context.tokens !== undefined)
-                contextParts.push(`${context.tokens} tokens`);
-            if (context.cost !== undefined)
-                contextParts.push(`$${context.cost.toFixed(6)}`);
-            // Add any other context properties
-            Object.keys(context).forEach(key => {
-                if (!['component', 'operation', 'duration', 'tokens', 'cost'].includes(key)) {
-                    contextParts.push(`${key}=${context[key]}`);
-                }
-            });
-            if (contextParts.length > 0) {
-                formatted += ` [${contextParts.join(', ')}]`;
-            }
-        }
-        return formatted;
-    }
-    error(message, context, ...args) {
-        if (this.level >= LogLevel.ERROR) {
-            const formatted = this.formatMessage('ERROR', message, context);
-            console.error(this.colors ? `\x1b[31m${formatted}\x1b[0m` : formatted, ...args);
-            // Write to file if enabled
-            if (this.fileLogging) {
-                this.writeToFile({
-                    timestamp: new Date().toISOString(),
-                    level: 'ERROR',
-                    message,
-                    component: context?.component,
-                    metadata: context ? { ...context } : undefined
-                });
-            }
-        }
-    }
-    warn(message, context, ...args) {
-        if (this.level >= LogLevel.WARN) {
-            const formatted = this.formatMessage('WARN', message, context);
-            console.warn(this.colors ? `\x1b[33m${formatted}\x1b[0m` : formatted, ...args);
-            // Write to file if enabled
-            if (this.fileLogging) {
-                this.writeToFile({
-                    timestamp: new Date().toISOString(),
-                    level: 'WARN',
-                    message,
-                    component: context?.component,
-                    metadata: context ? { ...context } : undefined
-                });
-            }
-        }
-    }
-    info(message, context, ...args) {
-        if (this.level >= LogLevel.INFO) {
-            const formatted = this.formatMessage('INFO', message, context);
-            logger.consoleLog(formatted, ...args);
-            // Write to file if enabled
-            if (this.fileLogging) {
-                this.writeToFile({
-                    timestamp: new Date().toISOString(),
-                    level: 'INFO',
-                    message,
-                    component: context?.component,
-                    metadata: context ? { ...context } : undefined
-                });
-            }
-        }
+let currentLevel = LogLevel.INFO;
+let logFilePath = null;
+let logBuffer = [];
+let logListeners = [];
+export function setLogLevel(level) {
+    currentLevel = level;
+}
+export function getLogLevel() {
+    return currentLevel;
+}
+export function onLog(listener) {
+    logListeners.push(listener);
+    // Return unsubscribe function
+    return () => {
+        logListeners = logListeners.filter(l => l !== listener);
+    };
+}
+export function getRecentLogs(count = 50) {
+    return logBuffer.slice(-count);
+}
+export function initLogFile() {
+    // Create logs directory
+    const logsDir = join(homedir(), '.local', 'share', 'protoagent', 'logs');
+    if (!existsSync(logsDir)) {
+        mkdirSync(logsDir, { recursive: true });
+    }
+    // Create log file with timestamp
+    const timestamp = new Date().toISOString().replace(/[:.]/g, '-');
+    logFilePath = join(logsDir, `protoagent-${timestamp}.log`);
+    // Write header
+    writeToFile(`\n${'='.repeat(80)}\nProtoAgent Log - ${new Date().toISOString()}\n${'='.repeat(80)}\n`);
+    return logFilePath;
+}
+function writeToFile(message) {
+    if (!logFilePath) {
+        initLogFile();
     }
-    debug(message, context, ...args) {
-        if (this.level >= LogLevel.DEBUG) {
-            const formatted = this.formatMessage('DEBUG', message, context);
-            logger.consoleLog(this.colors ? `\x1b[36m${formatted}\x1b[0m` : formatted, ...args);
-            // Write to file if enabled
-            if (this.fileLogging) {
-                this.writeToFile({
-                    timestamp: new Date().toISOString(),
-                    level: 'DEBUG',
-                    message,
-                    component: context?.component,
-                    metadata: context ? { ...context } : undefined
-                });
-            }
-        }
+    try {
+        appendFileSync(logFilePath, message);
     }
-    trace(message, context, ...args) {
-        if (this.level >= LogLevel.TRACE) {
-            const formatted = this.formatMessage('TRACE', message, context);
-            logger.consoleLog(this.colors ? `\x1b[90m${formatted}\x1b[0m` : formatted, ...args);
-            // Write to file if enabled
-            if (this.fileLogging) {
-                this.writeToFile({
-                    timestamp: new Date().toISOString(),
-                    level: 'TRACE',
-                    message,
-                    component: context?.component,
-                    metadata: context ? { ...context } : undefined
-                });
-            }
-        }
+    catch (err) {
+        // Silently fail if we can't write to log file
     }
-    // Convenience methods for common operations
-    startOperation(operation, component) {
-        const startTime = Date.now();
-        this.debug(`🚀 Starting: ${operation}`, { component, operation });
+}
+function timestamp() {
+    const d = new Date();
+    const hh = String(d.getHours()).padStart(2, '0');
+    const mm = String(d.getMinutes()).padStart(2, '0');
+    const ss = String(d.getSeconds()).padStart(2, '0');
+    const ms = String(d.getMilliseconds()).padStart(3, '0');
+    return `${hh}:${mm}:${ss}.${ms}`;
+}
+function log(level, label, message, context) {
+    if (level > currentLevel)
+        return;
+    const ts = timestamp();
+    // Create log entry
+    const entry = {
+        timestamp: ts,
+        level,
+        message,
+        context,
+    };
+    // Add to buffer (keep last 100 entries)
+    logBuffer.push(entry);
+    if (logBuffer.length > 100) {
+        logBuffer.shift();
+    }
+    // Notify listeners
+    logListeners.forEach(listener => listener(entry));
+    // Write to file
+    const ctx = context ? ` ${JSON.stringify(context)}` : '';
+    writeToFile(`[${ts}] ${label.padEnd(5)} ${message}${ctx}\n`);
+}
+export const logger = {
+    error: (msg, ctx) => log(LogLevel.ERROR, 'ERROR', msg, ctx),
+    warn: (msg, ctx) => log(LogLevel.WARN, 'WARN', msg, ctx),
+    info: (msg, ctx) => log(LogLevel.INFO, 'INFO', msg, ctx),
+    debug: (msg, ctx) => log(LogLevel.DEBUG, 'DEBUG', msg, ctx),
+    trace: (msg, ctx) => log(LogLevel.TRACE, 'TRACE', msg, ctx),
+    /** Start a timed operation. Call the returned `end()` to log the duration. */
+    startOperation(name) {
+        const start = performance.now();
+        logger.debug(`${name} started`);
         return {
-            end: (result) => {
-                const duration = Date.now() - startTime;
-                if (result && result.error) {
-                    this.error(`❌ Failed: ${operation}`, { component, operation, duration, error: result.error });
-                }
-                else {
-                    this.debug(`✅ Completed: ${operation}`, { component, operation, duration });
-                }
-            }
+            end() {
+                const ms = (performance.now() - start).toFixed(1);
+                logger.debug(`${name} completed`, { durationMs: ms });
+            },
         };
-    }
-    apiCall(operation, tokens, cost) {
-        const context = { component: 'API' };
-        if (tokens) {
-            context.tokens = tokens.input + tokens.output;
-            this.debug(`🌐 API Call: ${operation} (${tokens.input} in, ${tokens.output} out)`, context);
-        }
-        else {
-            this.debug(`🌐 API Call: ${operation}`, context);
-        }
-        if (cost) {
-            this.info(`💸 Estimated cost: $${cost.toFixed(6)}`, context);
-        }
-    }
-    toolExecution(toolName, duration, success = true) {
-        const emoji = success ? '✅' : '❌';
-        const level = success ? 'debug' : 'error';
-        this[level](`${emoji} Tool: ${toolName}`, { component: 'Tool', operation: toolName, duration });
-    }
-    contextInfo(current, max, percentage) {
-        const context = { component: 'Context', tokens: current };
-        if (percentage >= 90) {
-            this.warn(`📊 Context: ${current}/${max} tokens (${percentage.toFixed(1)}%) - approaching limit`, context);
-        }
-        else if (percentage >= 75) {
-            this.info(`📊 Context: ${current}/${max} tokens (${percentage.toFixed(1)}%)`, context);
-        }
-        else {
-            this.debug(`📊 Context: ${current}/${max} tokens (${percentage.toFixed(1)}%)`, context);
-        }
-    }
-    // Stream-safe output methods (don't interfere with streaming content)
-    streamSafeInfo(message) {
-        if (this.level >= LogLevel.INFO) {
-            process.stderr.write(`\n${message}\n`);
-        }
-    }
-    streamSafeDebug(message) {
-        if (this.level >= LogLevel.DEBUG) {
-            process.stderr.write(`\n[DEBUG] ${message}\n`);
-        }
-    }
-    /**
-     * ConsoleLog method - always logs to console and optionally to file
-     * This is the preferred method for user-facing output that should also be logged
-     * Use this instead of separate console.log + logger.debug calls
-     */
-    consoleLog(message, context, ...args) {
-        // Always output to console (no level filtering for consoleLog method)
-        console.log(message, ...args);
-        // Also write to file if enabled, at CONSOLE level (strip ANSI colors)
-        if (this.fileLogging) {
-            // Strip ANSI color codes from the message for clean file logging
-            const cleanMessage = message.replace(/\x1b\[[0-9;]*m/g, '');
-            this.writeToFile({
-                timestamp: new Date().toISOString(),
-                level: 'CONSOLE',
-                message: cleanMessage,
-                component: context?.component,
-                metadata: context ? { ...context } : undefined
-            });
-        }
-    }
-}
-export const logger = new Logger();
+    },
+    /** Get the path to the current log file */
+    getLogFilePath() {
+        return logFilePath;
+    },
+};

package/dist/utils/path-validation.js

@@ -0,0 +1,74 @@
+/**
+ * Path validation utility shared by all file tools.
+ *
+ * Ensures that every file path the agent operates on is within the
+ * working directory (process.cwd()). Prevents directory traversal
+ * and symlink escape attacks.
+ */
+import fs from 'node:fs/promises';
+import path from 'node:path';
+const workingDirectory = process.cwd();
+let allowedRoots = [];
+function isWithinRoot(targetPath, rootPath) {
+    const relative = path.relative(rootPath, targetPath);
+    return relative === '' || (!relative.startsWith('..') && !path.isAbsolute(relative));
+}
+function isAllowedPath(targetPath) {
+    return isWithinRoot(targetPath, workingDirectory) || allowedRoots.some((root) => isWithinRoot(targetPath, root));
+}
+export async function setAllowedPathRoots(roots) {
+    const normalizedRoots = await Promise.all(roots.map(async (root) => {
+        const resolved = path.resolve(root);
+        try {
+            const realRoot = await fs.realpath(resolved);
+            return [path.normalize(resolved), realRoot];
+        }
+        catch {
+            return [path.normalize(resolved)];
+        }
+    }));
+    allowedRoots = Array.from(new Set(normalizedRoots.flat()));
+}
+export function getAllowedPathRoots() {
+    return [...allowedRoots];
+}
+/**
+ * Resolve and validate a path. Throws if the path is outside cwd.
+ * For files that don't exist yet, validates the parent directory.
+ */
+export async function validatePath(requestedPath) {
+    const resolved = path.resolve(workingDirectory, requestedPath);
+    const normalized = path.normalize(resolved);
+    // First check: is the normalised path within cwd?
+    if (!isAllowedPath(normalized)) {
+        throw new Error(`Path "${requestedPath}" is outside the working directory.`);
+    }
+    // Second check: resolve symlinks and re-check
+    try {
+        const realPath = await fs.realpath(normalized);
+        if (!isAllowedPath(realPath)) {
+            throw new Error(`Path "${requestedPath}" resolves (via symlink) outside the working directory.`);
+        }
+        return realPath;
+    }
+    catch (err) {
+        if (err.code === 'ENOENT') {
+            // File doesn't exist yet — validate the parent directory instead
+            const parentDir = path.dirname(normalized);
+            try {
+                const realParent = await fs.realpath(parentDir);
+                if (!isAllowedPath(realParent)) {
+                    throw new Error(`Parent directory of "${requestedPath}" resolves outside the working directory.`);
+                }
+                return path.join(realParent, path.basename(normalized));
+            }
+            catch {
+                throw new Error(`Parent directory of "${requestedPath}" does not exist.`);
+            }
+        }
+        throw err;
+    }
+}
+export function getWorkingDirectory() {
+    return workingDirectory;
+}