protoagent 0.0.1

package/dist/utils/logger.js

@@ -0,0 +1,149 @@
+/**
+ * Configurable logging utility for ProtoAgent
+ */
+export var LogLevel;
+(function (LogLevel) {
+    LogLevel[LogLevel["ERROR"] = 0] = "ERROR";
+    LogLevel[LogLevel["WARN"] = 1] = "WARN";
+    LogLevel[LogLevel["INFO"] = 2] = "INFO";
+    LogLevel[LogLevel["DEBUG"] = 3] = "DEBUG";
+    LogLevel[LogLevel["TRACE"] = 4] = "TRACE";
+})(LogLevel || (LogLevel = {}));
+class Logger {
+    constructor() {
+        this.level = LogLevel.INFO;
+        this.timestamps = true;
+        this.colors = true;
+    }
+    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);
+        }
+    }
+    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);
+        }
+    }
+    info(message, context, ...args) {
+        if (this.level >= LogLevel.INFO) {
+            const formatted = this.formatMessage('INFO', message, context);
+            console.log(formatted, ...args);
+        }
+    }
+    debug(message, context, ...args) {
+        if (this.level >= LogLevel.DEBUG) {
+            const formatted = this.formatMessage('DEBUG', message, context);
+            console.log(this.colors ? `\x1b[36m${formatted}\x1b[0m` : formatted, ...args);
+        }
+    }
+    trace(message, context, ...args) {
+        if (this.level >= LogLevel.TRACE) {
+            const formatted = this.formatMessage('TRACE', message, context);
+            console.log(this.colors ? `\x1b[90m${formatted}\x1b[0m` : formatted, ...args);
+        }
+    }
+    // Convenience methods for common operations
+    startOperation(operation, component) {
+        const startTime = Date.now();
+        this.debug(`🚀 Starting: ${operation}`, { component, operation });
+        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 });
+                }
+            }
+        };
+    }
+    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`);
+        }
+    }
+}
+export const logger = new Logger();

package/package.json

@@ -0,0 +1,61 @@
+{
+  "name": "protoagent",
+  "version": "0.0.1",
+  "description": "Interactive AI coding agent CLI with file system capabilities and shell command execution",
+  "type": "module",
+  "main": "dist/index.js",
+  "bin": {
+    "protoagent": "dist/index.js"
+  },
+  "scripts": {
+    "build": "tsc",
+    "dev": "tsx src/index.ts",
+    "start": "node dist/index.js",
+    "prepublishOnly": "npm run build",
+    "prepack": "npm run build"
+  },
+  "keywords": [
+    "cli",
+    "ai",
+    "coding-assistant",
+    "agent",
+    "coding",
+    "typescript",
+    "interactive",
+    "openai",
+    "file-system",
+    "shell-commands",
+    "developer-tools"
+  ],
+  "author": "Thomas Gauvin",
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/thomasgauvin/protoagent.git"
+  },
+  "bugs": {
+    "url": "https://github.com/thomasgauvin/protoagent/issues"
+  },
+  "homepage": "https://github.com/thomasgauvin/protoagent#readme",
+  "devDependencies": {
+    "@types/inquirer": "^9.0.9",
+    "@types/node": "^20.0.0",
+    "dotenv": "^17.2.1",
+    "tsx": "^4.7.0",
+    "typescript": "^5.0.0"
+  },
+  "dependencies": {
+    "commander": "^11.0.0",
+    "inquirer": "^9.3.7",
+    "openai": "^5.11.0",
+    "zod": "^3.25.76"
+  },
+  "engines": {
+    "node": ">=16.0.0"
+  },
+  "files": [
+    "dist/**/*",
+    "README.md",
+    "LICENSE"
+  ]
+}