autoclaw 1.0.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2024 AutoClaw Contributor
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,47 @@
+# AutoClaw 🦞
+
+AutoClaw is a lightweight AI agent CLI tool that brings the power of Large Language Models (LLMs) directly to your terminal. It allows you to interact with your file system and execute commands using natural language.
+
+## Features
+
+- 💬 **Natural Language Interface**: Chat with your terminal to perform complex tasks.
+- 🛡️ **Safe Execution**: All shell commands require user confirmation before execution.
+- 📂 **File Management**: Read and write files effortlessly.
+- 🧠 **Context Aware**: Automatically detects your OS, shell, and environment for accurate command generation.
+- 🔌 **Model Agnostic**: Compatible with OpenAI, DeepSeek, LocalLLM, or any OpenAI-compatible API.
+
+## Installation
+
+```bash
+npm install -g autoclaw
+```
+
+## Quick Start
+
+1.  **Setup**: Run the setup wizard to configure your API key.
+    ```bash
+    autoclaw setup
+    ```
+2.  **Run**: Start the agent.
+    ```bash
+    autoclaw
+    ```
+
+## Usage Examples
+
+- "List all TypeScript files in the src folder."
+- "Create a new React component named Button in `components/Button.tsx`."
+- "Check my disk usage and tell me which folder is the largest."
+
+## Configuration
+
+AutoClaw uses a `.env` file in the current working directory or creates one globally during setup.
+
+Supported Environment Variables:
+- `OPENAI_API_KEY`: Your API Key.
+- `OPENAI_BASE_URL`: Custom Base URL (e.g., for LocalLLM or other providers).
+- `OPENAI_MODEL`: Default model to use (default: `gpt-4o`).
+
+## License
+
+MIT

package/dist/agent.js

@@ -0,0 +1,93 @@
+import OpenAI from 'openai';
+import chalk from 'chalk';
+import ora from 'ora';
+import * as os from 'os';
+import { tools, executeTool } from './tools.js';
+export class Agent {
+    client;
+    messages;
+    model;
+    constructor(apiKey, baseURL, model = 'gpt-4-turbo-preview') {
+        this.client = new OpenAI({
+            apiKey: apiKey,
+            baseURL: baseURL
+        });
+        this.model = model;
+        const systemInfo = `
+System Information:
+- OS: ${os.type()} ${os.release()} (${os.platform()})
+- Architecture: ${os.arch()}
+- Node.js Version: ${process.version}
+- Current Working Directory: ${process.cwd()}
+- User: ${os.userInfo().username}
+- Home Directory: ${os.homedir()}
+`;
+        this.messages = [
+            {
+                role: "system",
+                content: `You are AutoClaw, an advanced AI agent running in a CLI environment.
+Your goal is to help the user perform tasks on their computer.
+You have access to tools to execute shell commands and read/write files.
+
+CONTEXT:
+${systemInfo}
+
+GUIDELINES:
+1. Use the System Information above to generate platform-specific commands (e.g., use 'dir' for Windows, 'ls' for Linux).
+2. When asked to perform a task, analyze if you need to use tools.
+3. If you need to run a command, always use 'execute_shell_command' and provide a clear rationale.
+4. If you need to read a file, use 'read_file'.
+5. If you need to write a file, use 'write_file'.
+6. Be concise in your responses.
+7. If the user's request is ambiguous, ask for clarification.
+8. You are running on the user's local machine. Be careful with destructive commands (rm, etc.).
+`
+            }
+        ];
+    }
+    async chat(userInput) {
+        this.messages.push({ role: "user", content: userInput });
+        let active = true;
+        while (active) {
+            const spinner = ora('Thinking...').start();
+            try {
+                const response = await this.client.chat.completions.create({
+                    model: this.model,
+                    messages: this.messages,
+                    tools: tools,
+                    tool_choice: "auto"
+                });
+                spinner.stop();
+                const message = response.choices[0].message;
+                this.messages.push(message);
+                if (message.content) {
+                    console.log(chalk.blue("AutoClaw: ") + message.content);
+                }
+                if (message.tool_calls) {
+                    for (const toolCall of message.tool_calls) {
+                        if (toolCall.type !== 'function')
+                            continue;
+                        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);
+                        this.messages.push({
+                            role: "tool",
+                            tool_call_id: toolCall.id,
+                            content: toolResult
+                        });
+                        // console.log(chalk.dim(`Tool Output: ${toolResult.slice(0, 100)}...`));
+                    }
+                }
+                else {
+                    active = false;
+                }
+            }
+            catch (error) {
+                spinner.fail('Error during processing');
+                console.error(chalk.red(error.message));
+                active = false;
+            }
+        }
+    }
+}

package/dist/index.js

@@ -0,0 +1,114 @@
+#!/usr/bin/env node
+import { Command } from 'commander';
+import inquirer from 'inquirer';
+import chalk from 'chalk';
+import dotenv from 'dotenv';
+import { Agent } from './agent.js';
+import * as fs from 'fs';
+import * as path from 'path';
+// Load env vars
+dotenv.config();
+const program = new Command();
+program
+    .name('autoclaw')
+    .description('A lightweight AI agent CLI tool')
+    .version('1.0.0');
+program
+    .command('setup')
+    .description('Run the interactive setup wizard to configure API keys')
+    .action(async () => {
+    await runSetup();
+});
+program
+    .command('chat', { isDefault: true })
+    .description('Start the AI agent (default)')
+    .option('-m, --model <model>', 'Model to use')
+    .action(async (options) => {
+    await runChat(options);
+});
+program.parse(process.argv);
+async function runSetup() {
+    console.log(chalk.bold.cyan("AutoClaw Setup Wizard 🦞\n"));
+    const answers = await inquirer.prompt([
+        {
+            type: 'password',
+            name: 'apiKey',
+            message: 'Enter your OpenAI API Key:',
+            mask: '*',
+            validate: (input) => input.length > 0 ? true : 'API Key cannot be empty.'
+        },
+        {
+            type: 'input',
+            name: 'baseUrl',
+            message: 'Enter API Base URL (optional, press Enter for default):',
+            default: 'https://api.openai.com/v1'
+        },
+        {
+            type: 'input',
+            name: 'model',
+            message: 'Enter default Model:',
+            default: 'gpt-4o'
+        }
+    ]);
+    const envContent = `OPENAI_API_KEY=${answers.apiKey}
+OPENAI_BASE_URL=${answers.baseUrl}
+OPENAI_MODEL=${answers.model}
+`;
+    const envPath = path.resolve(process.cwd(), '.env');
+    fs.writeFileSync(envPath, envContent);
+    console.log(chalk.green(`\n✅ Configuration saved to ${envPath}`));
+    console.log(chalk.cyan("You can now run 'autoclaw' to start using the agent."));
+}
+async function runChat(options) {
+    console.log(chalk.bold.cyan("Welcome to AutoClaw CLI 🦞"));
+    let apiKey = process.env.OPENAI_API_KEY;
+    let baseURL = process.env.OPENAI_BASE_URL;
+    // Priority: CLI arg > Env var > Default
+    const model = options.model || process.env.OPENAI_MODEL || 'gpt-4o';
+    if (!apiKey) {
+        console.log(chalk.yellow("API Key not found."));
+        const { doSetup } = await inquirer.prompt([
+            {
+                type: 'confirm',
+                name: 'doSetup',
+                message: 'Would you like to run the setup wizard now?',
+                default: true
+            }
+        ]);
+        if (doSetup) {
+            await runSetup();
+            // Reload env
+            dotenv.config({ override: true });
+            apiKey = process.env.OPENAI_API_KEY;
+            baseURL = process.env.OPENAI_BASE_URL;
+        }
+        else {
+            console.error(chalk.red("API Key is required to proceed."));
+            process.exit(1);
+        }
+    }
+    // Double check if apiKey is present after potential setup
+    if (!apiKey) {
+        console.error(chalk.red("API Key is still missing. Exiting."));
+        process.exit(1);
+    }
+    const agent = new Agent(apiKey, baseURL, model);
+    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 >'
+            }
+        ]);
+        if (userInput.toLowerCase() === 'exit' || userInput.toLowerCase() === 'quit') {
+            console.log(chalk.cyan("Goodbye!"));
+            break;
+        }
+        if (userInput.trim() === '')
+            continue;
+        await agent.chat(userInput);
+    }
+}

package/dist/tools.js

@@ -0,0 +1,130 @@
+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 tools = [
+    {
+        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 (e.g., 'ls -la', 'npm install')."
+                    },
+                    rationale: {
+                        type: "string",
+                        description: "Explain why you are running this command."
+                    }
+                },
+                required: ["command", "rationale"]
+            }
+        }
+    },
+    {
+        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"]
+            }
+        }
+    },
+    {
+        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 to the file."
+                    }
+                },
+                required: ["path", "content"]
+            }
+        }
+    }
+];
+export async function executeTool(name, args) {
+    try {
+        switch (name) {
+            case 'execute_shell_command':
+                return await executeShellCommand(args.command, args.rationale);
+            case 'read_file':
+                return await readFile(args.path);
+            case 'write_file':
+                return await writeFile(args.path, args.content);
+            default:
+                return `Error: Unknown tool ${name}`;
+        }
+    }
+    catch (error) {
+        return `Error executing ${name}: ${error.message}`;
+    }
+}
+async function executeShellCommand(command, rationale) {
+    console.log(chalk.yellow(`
+AI wants to execute: `) + chalk.bold(command));
+    console.log(chalk.dim(`Reason: ${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(command);
+        return stdout + (stderr ? `
+Stderr: ${stderr}` : '');
+    }
+    catch (error) {
+        return `Command failed: ${error.message}
+Stdout: ${error.stdout}
+Stderr: ${error.stderr}`;
+    }
+}
+async function readFile(filePath) {
+    try {
+        const content = await fs.readFile(filePath, 'utf-8');
+        return content;
+    }
+    catch (error) {
+        return `Error reading file: ${error.message}`;
+    }
+}
+async function writeFile(filePath, content) {
+    try {
+        await fs.mkdir(path.dirname(filePath), { recursive: true });
+        await fs.writeFile(filePath, content, 'utf-8');
+        return `Successfully wrote to ${filePath}`;
+    }
+    catch (error) {
+        return `Error writing file: ${error.message}`;
+    }
+}

package/package.json

@@ -0,0 +1,47 @@
+{
+  "name": "autoclaw",
+  "version": "1.0.0",
+  "type": "module",
+  "main": "dist/index.js",
+  "bin": {
+    "autoclaw": "./dist/index.js"
+  },
+  "scripts": {
+    "build": "tsc",
+    "start": "node dist/index.js",
+    "dev": "node --loader ts-node/esm src/index.ts",
+    "test": "echo \"Error: no test specified\" && exit 1",
+    "prepublishOnly": "npm run build"
+  },
+  "files": [
+    "dist",
+    "README.md",
+    "package.json",
+    "LICENSE"
+  ],
+  "keywords": [
+    "ai",
+    "cli",
+    "agent",
+    "automation",
+    "openai",
+    "tool"
+  ],
+  "author": "AutoClaw Contributor",
+  "license": "MIT",
+  "description": "A lightweight AI agent CLI tool that brings the power of LLMs to your terminal.",
+  "dependencies": {
+    "chalk": "^5.6.2",
+    "commander": "^14.0.3",
+    "dotenv": "^17.2.4",
+    "inquirer": "^13.2.2",
+    "openai": "^6.18.0",
+    "ora": "^9.3.0"
+  },
+  "devDependencies": {
+    "@types/inquirer": "^9.0.9",
+    "@types/node": "^25.2.1",
+    "ts-node": "^10.9.2",
+    "typescript": "^5.9.3"
+  }
+}