autoclaw 1.0.5 → 1.0.7

package/dist/agent.js

@@ -2,17 +2,19 @@ import OpenAI from 'openai';
 import chalk from 'chalk';
 import ora from 'ora';
 import * as os from 'os';
-import { tools, executeTool } from './tools.js';
+import { getToolDefinitions, executeToolHandler } from './tools/index.js';
 export class Agent {
     client;
     messages;
     model;
-    constructor(apiKey, baseURL, model = 'gpt-4-turbo-preview') {
+    config;
+    constructor(apiKey, baseURL, model = 'gpt-4-turbo-preview', config = {}) {
         this.client = new OpenAI({
             apiKey: apiKey,
             baseURL: baseURL
         });
         this.model = model;
+        this.config = config;
         const systemInfo = `
 System Information:
 - OS: ${os.type()} ${os.release()} (${os.platform()})
@@ -54,7 +56,7 @@ GUIDELINES:
                 const response = await this.client.chat.completions.create({
                     model: this.model,
                     messages: this.messages,
-                    tools: tools,
+                    tools: getToolDefinitions(),
                     tool_choice: "auto"
                 });
                 spinner.stop();
@@ -70,13 +72,13 @@ GUIDELINES:
                         const functionName = toolCall.function.name;
                         const functionArgs = JSON.parse(toolCall.function.arguments);
                         console.log(chalk.gray(`Executing tool: ${functionName}...`));
-                        const toolResult = await executeTool(functionName, functionArgs);
+                        // Pass the full config to the tool handler
+                        const toolResult = await executeToolHandler(functionName, functionArgs, this.config);
                         this.messages.push({
                             role: "tool",
                             tool_call_id: toolCall.id,
                             content: toolResult
                         });
-                        // console.log(chalk.dim(`Tool Output: ${toolResult.slice(0, 100)}...`));
                     }
                 }
                 else {

package/dist/index.js

@@ -8,6 +8,11 @@ import * as fs from 'fs';
 import * as path from 'path';
 import * as os from 'os';
 import { fileURLToPath } from 'url';
+// Handle Ctrl+C gracefully
+process.on('SIGINT', () => {
+    console.log(chalk.cyan("\n\nGoodbye! (Interrupted)"));
+    process.exit(0);
+});
 const GLOBAL_CONFIG_DIR = path.join(os.homedir(), '.autoclaw');
 const GLOBAL_CONFIG_FILE = path.join(GLOBAL_CONFIG_DIR, 'setting.json');
 const LOCAL_CONFIG_FILE = path.join(process.cwd(), '.autoclaw', 'setting.json');
@@ -22,7 +27,7 @@ function loadJsonConfig(filePath) {
     }
     return {};
 }
-// Load local env vars
+// Load local env vars (lowest priority of env vars, but env vars override JSON)
 dotenv.config();
 const __dirname = path.dirname(fileURLToPath(import.meta.url));
 // In dist/index.js, package.json is usually up one level in the root
@@ -78,12 +83,55 @@ async function runSetup() {
             name: 'model',
             message: 'Enter default Model:',
             default: currentConfig.model || 'gpt-4o'
+        },
+        {
+            type: 'confirm',
+            name: 'configureEmail',
+            message: 'Do you want to configure the Email Tool (SMTP)?',
+            default: !!currentConfig.smtpHost
         }
     ]);
+    let emailConfig = {};
+    if (answers.configureEmail) {
+        emailConfig = await inquirer.prompt([
+            {
+                type: 'input',
+                name: 'smtpHost',
+                message: 'SMTP Host:',
+                default: currentConfig.smtpHost
+            },
+            {
+                type: 'input',
+                name: 'smtpPort',
+                message: 'SMTP Port:',
+                default: currentConfig.smtpPort || '587'
+            },
+            {
+                type: 'input',
+                name: 'smtpUser',
+                message: 'SMTP Username:',
+                default: currentConfig.smtpUser
+            },
+            {
+                type: 'password',
+                name: 'smtpPass',
+                message: 'SMTP Password:',
+                mask: '*',
+                default: currentConfig.smtpPass
+            },
+            {
+                type: 'input',
+                name: 'smtpFrom',
+                message: 'Sender Email Address (From):',
+                default: currentConfig.smtpFrom || emailConfig.smtpUser
+            }
+        ]);
+    }
     const newConfig = {
         apiKey: answers.apiKey,
         baseUrl: answers.baseUrl,
-        model: answers.model
+        model: answers.model,
+        ...emailConfig
     };
     try {
         if (!fs.existsSync(GLOBAL_CONFIG_DIR)) {
@@ -106,10 +154,22 @@ async function runChat(options) {
     if (Object.keys(localConfig).length > 0) {
         console.log(chalk.dim(`Loaded project config from ${LOCAL_CONFIG_FILE}`));
     }
-    // 3. Merge: CLI > Env > Local JSON > Global JSON
-    let apiKey = process.env.OPENAI_API_KEY || localConfig.apiKey || globalConfig.apiKey;
-    let baseURL = process.env.OPENAI_BASE_URL || localConfig.baseUrl || globalConfig.baseUrl;
-    let model = options.model || process.env.OPENAI_MODEL || localConfig.model || globalConfig.model || 'gpt-4o';
+    // 3. Merge Configs for Tool Usage
+    // Priority: Local > Global
+    const fullConfig = { ...globalConfig, ...localConfig };
+    // 4. Resolve Env Vars (CLI > Env > Config)
+    let apiKey = process.env.OPENAI_API_KEY || fullConfig.apiKey;
+    let baseURL = process.env.OPENAI_BASE_URL || fullConfig.baseUrl;
+    let model = options.model || process.env.OPENAI_MODEL || fullConfig.model || 'gpt-4o';
+    // Inject Env vars for SMTP if present (optional but good for CI/CD)
+    if (process.env.SMTP_HOST)
+        fullConfig.smtpHost = process.env.SMTP_HOST;
+    if (process.env.SMTP_PORT)
+        fullConfig.smtpPort = process.env.SMTP_PORT;
+    if (process.env.SMTP_USER)
+        fullConfig.smtpUser = process.env.SMTP_USER;
+    if (process.env.SMTP_PASS)
+        fullConfig.smtpPass = process.env.SMTP_PASS;
     if (!apiKey) {
         console.log(chalk.yellow("API Key not found."));
         const { doSetup } = await inquirer.prompt([
@@ -126,6 +186,7 @@ async function runChat(options) {
             apiKey = newConfig.apiKey;
             baseURL = newConfig.baseUrl;
             model = options.model || newConfig.model || 'gpt-4o';
+            Object.assign(fullConfig, newConfig);
         }
         else {
             console.error(chalk.red("API Key is required to proceed."));
@@ -136,23 +197,47 @@ async function runChat(options) {
         console.error(chalk.red("API Key is still missing. Exiting."));
         process.exit(1);
     }
-    const agent = new Agent(apiKey, baseURL, model);
+    const agent = new Agent(apiKey, baseURL, model, fullConfig);
     console.log(chalk.green(`Agent initialized with model: ${model}`));
     console.log(chalk.gray("Type 'exit' or 'quit' to leave."));
-    while (true) {
-        const { userInput } = await inquirer.prompt([
-            {
-                type: 'input',
-                name: 'userInput',
-                message: 'You >'
+    // Main chat loop
+    try {
+        while (true) {
+            const { userInput } = await inquirer.prompt([
+                {
+                    type: 'input',
+                    name: 'userInput',
+                    message: 'You >'
+                }
+            ]);
+            if (userInput.toLowerCase() === 'exit' || userInput.toLowerCase() === 'quit') {
+                console.log(chalk.cyan("Goodbye!"));
+                break;
             }
-        ]);
-        if (userInput.toLowerCase() === 'exit' || userInput.toLowerCase() === 'quit') {
-            console.log(chalk.cyan("Goodbye!"));
-            break;
+            if (userInput.trim() === '')
+                continue;
+            await agent.chat(userInput);
+        }
+    }
+    catch (err) {
+        // Check for Inquirer interruption error (Ctrl+C often causes this)
+        if (err.message && (err.message.includes('User force closed') || err.message.includes('Prompt was canceled'))) {
+            console.log(chalk.cyan("\nGoodbye!"));
+            process.exit(0);
         }
-        if (userInput.trim() === '')
-            continue;
-        await agent.chat(userInput);
+        throw err; // Re-throw real errors to be caught by main().catch
     }
 }
+// Global error handler
+main().catch(err => {
+    if (err.message && (err.message.includes('User force closed') || err.message.includes('Prompt was canceled'))) {
+        console.log(chalk.cyan("\nGoodbye!"));
+        process.exit(0);
+    }
+    console.error(chalk.red("Fatal Error:"), err);
+    process.exit(1);
+});
+async function main() {
+    // Just a wrapper to keep the promise chain clean if needed, 
+    // but currently logic is triggered by program.parse()
+}

package/dist/tools/core.js

@@ -0,0 +1,104 @@
+import { exec } from 'child_process';
+import * as fs from 'fs/promises';
+import * as path from 'path';
+import inquirer from 'inquirer';
+import chalk from 'chalk';
+import util from 'util';
+const execAsync = util.promisify(exec);
+export const ShellTool = {
+    name: "Shell Execution",
+    definition: {
+        type: "function",
+        function: {
+            name: "execute_shell_command",
+            description: "Execute a shell command on the host machine. Use this to run scripts, list files, or interact with the system.",
+            parameters: {
+                type: "object",
+                properties: {
+                    command: { type: "string", description: "The shell command to execute." },
+                    rationale: { type: "string", description: "Explain why you are running this command." }
+                },
+                required: ["command", "rationale"]
+            }
+        }
+    },
+    handler: async (args) => {
+        console.log(chalk.yellow(`
+AI wants to execute: `) + chalk.bold(args.command));
+        console.log(chalk.dim(`Reason: ${args.rationale}`));
+        const { confirm } = await inquirer.prompt([
+            {
+                type: 'confirm',
+                name: 'confirm',
+                message: 'Do you want to run this command?',
+                default: false
+            }
+        ]);
+        if (!confirm)
+            return "User denied command execution.";
+        try {
+            const { stdout, stderr } = await execAsync(args.command);
+            return stdout + (stderr ? `
+Stderr: ${stderr}` : '');
+        }
+        catch (error) {
+            return `Command failed: ${error.message}
+Stdout: ${error.stdout}
+Stderr: ${error.stderr}`;
+        }
+    }
+};
+export const ReadFileTool = {
+    name: "File Reader",
+    definition: {
+        type: "function",
+        function: {
+            name: "read_file",
+            description: "Read the content of a file.",
+            parameters: {
+                type: "object",
+                properties: {
+                    path: { type: "string", description: "The path to the file to read." }
+                },
+                required: ["path"]
+            }
+        }
+    },
+    handler: async (args) => {
+        try {
+            const content = await fs.readFile(args.path, 'utf-8');
+            return content;
+        }
+        catch (error) {
+            return `Error reading file: ${error.message}`;
+        }
+    }
+};
+export const WriteFileTool = {
+    name: "File Writer",
+    definition: {
+        type: "function",
+        function: {
+            name: "write_file",
+            description: "Write content to a file. Overwrites existing files.",
+            parameters: {
+                type: "object",
+                properties: {
+                    path: { type: "string", description: "The path to the file to write." },
+                    content: { type: "string", description: "The content to write." }
+                },
+                required: ["path", "content"]
+            }
+        }
+    },
+    handler: async (args) => {
+        try {
+            await fs.mkdir(path.dirname(args.path), { recursive: true });
+            await fs.writeFile(args.path, args.content, 'utf-8');
+            return `Successfully wrote to ${args.path}`;
+        }
+        catch (error) {
+            return `Error writing file: ${error.message}`;
+        }
+    }
+};

package/dist/tools/email.js

@@ -0,0 +1,48 @@
+import nodemailer from 'nodemailer';
+export const EmailTool = {
+    name: "Email Service",
+    configKeys: ["smtpHost", "smtpPort", "smtpUser", "smtpPass", "smtpFrom"],
+    definition: {
+        type: "function",
+        function: {
+            name: "send_email",
+            description: "Send an email using configured SMTP settings.",
+            parameters: {
+                type: "object",
+                properties: {
+                    to: { type: "string", description: "Recipient email address." },
+                    subject: { type: "string", description: "Email subject." },
+                    body: { type: "string", description: "Email body content (text)." }
+                },
+                required: ["to", "subject", "body"]
+            }
+        }
+    },
+    handler: async (args, config) => {
+        // Validate config
+        if (!config?.smtpHost || !config?.smtpUser || !config?.smtpPass) {
+            return "Error: Email tool is not configured. Please run 'autoclaw setup' to configure SMTP settings.";
+        }
+        try {
+            const transporter = nodemailer.createTransport({
+                host: config.smtpHost,
+                port: parseInt(config.smtpPort || '587'),
+                secure: parseInt(config.smtpPort) === 465, // true for 465, false for other ports
+                auth: {
+                    user: config.smtpUser,
+                    pass: config.smtpPass,
+                },
+            });
+            const info = await transporter.sendMail({
+                from: config.smtpFrom || config.smtpUser, // sender address
+                to: args.to, // list of receivers
+                subject: args.subject, // Subject line
+                text: args.body, // plain text body
+            });
+            return `Email sent successfully. Message ID: ${info.messageId}`;
+        }
+        catch (error) {
+            return `Failed to send email: ${error.message}`;
+        }
+    }
+};

package/dist/tools/index.js

@@ -0,0 +1,29 @@
+import { ShellTool, ReadFileTool, WriteFileTool } from './core.js';
+import { EmailTool } from './email.js';
+// Central Registry of all available tools
+export const toolRegistry = [
+    ShellTool,
+    ReadFileTool,
+    WriteFileTool,
+    EmailTool
+];
+export function getToolDefinitions() {
+    return toolRegistry.map(t => t.definition);
+}
+export async function executeToolHandler(name, args, fullConfig) {
+    const tool = toolRegistry.find(t => t.definition.function.name === name);
+    if (!tool) {
+        return `Error: Tool ${name} not found.`;
+    }
+    // Pass specific config if needed (e.g., email config)
+    // We pass the full config, and let the handler pick what it needs or strictly pass the 'tools' section if structured.
+    // For simplicity, passing full config, or we can structure config.tools.email
+    // Let's assume config has a 'tools' dictionary.
+    const toolConfig = fullConfig.tools ? fullConfig.tools[name] : fullConfig;
+    // Actually, let's just pass the root config for now to keep migration simple, 
+    // or better, pass the 'email' specific config if we structure it.
+    // Strategy: In setup, we will save keys like 'smtpHost' at root or under 'tools.email'.
+    // Let's keep it flat or structured? Structured is better for plugins.
+    // Let's pass the whole config object to the handler, it can pick what it needs.
+    return await tool.handler(args, fullConfig);
+}

package/dist/tools/interface.js

@@ -0,0 +1 @@
+export {};

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "autoclaw",
-  "version": "1.0.5",
+  "version": "1.0.7",
   "type": "module",
   "main": "dist/index.js",
   "bin": {
@@ -35,12 +35,14 @@
     "commander": "^14.0.3",
     "dotenv": "^16.4.7",
     "inquirer": "^13.2.2",
+    "nodemailer": "^8.0.0",
     "openai": "^6.18.0",
     "ora": "^9.3.0"
   },
   "devDependencies": {
     "@types/inquirer": "^9.0.9",
     "@types/node": "^25.2.1",
+    "@types/nodemailer": "^7.0.9",
     "ts-node": "^10.9.2",
     "typescript": "^5.9.3"
   }