aela-ai 1.0.0

package/README.md

@@ -0,0 +1,86 @@
+# 🦇 Aela - Your Terminal AI Sidekick
+
+![Aela the Axolotl](image.png)
+
+> An agentic, terminal-based AI assistant powered by OpenRouter.
+
+Aela is a lightweight but powerful agentic CLI tool. It brings autonomous AI capabilities directly into your terminal, allowing you to converse with LLMs that can read your local files, write code, and execute bash commands on your behalf.
+
+Whether you need to analyze a Git repository, refactor an entire directory, or scaffold a new project, Aela acts as your personal terminal sidekick.
+
+## ✨ Features
+
+- **Agentic Capabilities:** Aela doesn't just chat. He has direct access to read/write files, execute bash commands, fetch full webpages, search the web (via Tavily), and even pause to ask you for clarification mid-task.
+- **Interactive REPL Mode:** Drop into a continuous, multi-turn chat session with persistent memory (`aela repl`).
+- **Beautiful Theming:** A polished, color-coded terminal UX built with `picocolors`.
+- **Model Agnostic:** Powered by OpenRouter, you can instantly switch between the best models (e.g., GPT-4, Claude 3.5 Sonnet, Llama 3) directly from the CLI.
+- **Zero-Friction Setup:** Automatically prompts and securely stores your API keys locally (`~/.aela/config.json`) on first run. No messy environment variables required.
+- **Lightweight & Fast:** Built entirely in TypeScript with a minimal footprint.
+
+## 🚀 Installation
+
+You can install Aela globally on your system using npm:
+
+```bash
+npm install -g .
+```
+
+*Note: You may need to run `npm run build` if the `dist/` directory is not already compiled.*
+
+## 💻 Usage
+
+Simply type `aela` followed by your prompt for one-shot execution, or type `aela repl` to drop into a continuous chat session with persistent memory. No flags necessary.
+
+```bash
+# Start an interactive REPL session
+aela repl
+
+# Read files and summarize
+aela read package.json and summarize what this project does
+
+# Search and analyze codebase
+aela find all TODO comments in my codebase
+
+# Write code and scaffold
+aela create a new python script that scrapes a website
+
+# Search the Web
+aela Search the web for the latest news about OpenAI
+
+# Fetch and Read Webpages
+aela Go to https://news.ycombinator.com and list the top 3 stories right now
+```
+
+To see the interactive welcome screen and all available commands, simply run:
+```bash
+aela help
+```
+
+## ⚙️ Configuration
+
+Aela allows you to easily configure your preferences on the fly. 
+
+- **Select Model:** Fetch and choose from a dynamic list of available OpenRouter models:
+  ```bash
+  aela config model
+  ```
+- **Set API Key (OpenRouter):**
+  ```bash
+  aela config apiKey <your-key>
+  ```
+- **Set Web Search API Key (Tavily):**
+  ```bash
+  aela config tavilyApiKey <your-key>
+  ```
+- **Set Max Tokens:** (Useful to prevent OpenRouter 402 Credit limit errors)
+  ```bash
+  aela config maxTokens 4000
+  ```
+
+## 🛠️ Built With
+- [TypeScript](https://www.typescriptlang.org/)
+- [Node.js](https://nodejs.org/)
+- [OpenAI Node SDK](https://github.com/openai/openai-node) (configured for OpenRouter)
+
+---
+*Built as a lightweight alternative to full-scale agentic terminal environments.*

package/dist/app/main.js

@@ -0,0 +1,152 @@
+#!/usr/bin/env node
+import OpenAI from "openai";
+import * as fs from "fs";
+import { exec as execCallback } from "child_process";
+import { promisify } from "util";
+const exec = promisify(execCallback);
+async function main() {
+    const [, , flag, prompt] = process.argv;
+    const apiKey = process.env.OPENROUTER_API_KEY;
+    const baseURL = process.env.OPENROUTER_BASE_URL ?? "https://openrouter.ai/api/v1";
+    if (!apiKey) {
+        throw new Error("OPENROUTER_API_KEY is not set");
+    }
+    if (flag !== "-p" || !prompt) {
+        throw new Error("error: -p flag is required");
+    }
+    const client = new OpenAI({
+        apiKey: apiKey,
+        baseURL: baseURL,
+    });
+    const messages = [
+        { role: "user", content: prompt }
+    ];
+    const tools = [{
+            "type": "function",
+            "function": {
+                "name": "Read",
+                "description": "Read and return the contents of a file",
+                "parameters": {
+                    "type": "object",
+                    "properties": {
+                        "file_path": {
+                            "type": "string",
+                            "description": "The path to the file to read"
+                        }
+                    },
+                    "required": ["file_path"]
+                }
+            }
+        },
+        {
+            "type": "function",
+            "function": {
+                "name": "Write",
+                "description": "Write content to a file",
+                "parameters": {
+                    "type": "object",
+                    "required": ["file_path", "content"],
+                    "properties": {
+                        "file_path": {
+                            "type": "string",
+                            "description": "The path of the file to write to"
+                        },
+                        "content": {
+                            "type": "string",
+                            "description": "The content to write to the file"
+                        }
+                    }
+                }
+            }
+        },
+        {
+            "type": "function",
+            "function": {
+                "name": "Bash",
+                "description": "Execute a shell command",
+                "parameters": {
+                    "type": "object",
+                    "required": ["command"],
+                    "properties": {
+                        "command": {
+                            "type": "string",
+                            "description": "The command to execute"
+                        }
+                    }
+                }
+            }
+        }];
+    while (true) {
+        const response = await client.chat.completions.create({
+            model: "anthropic/claude-haiku-4.5",
+            messages: messages,
+            max_completion_tokens: 7000,
+            tools: tools
+        });
+        if (!response.choices || response.choices.length === 0) {
+            throw new Error("no choices in response");
+        }
+        const message = response.choices[0].message;
+        messages.push(message);
+        if (!message.tool_calls || message.tool_calls.length === 0) {
+            if (message.content) {
+                console.log(message.content);
+            }
+            break;
+        }
+        for (const toolCall of message.tool_calls) {
+            if (toolCall.type === "function" && toolCall.function.name === "Read") {
+                const args = JSON.parse(toolCall.function.arguments);
+                let content = "";
+                try {
+                    content = fs.readFileSync(args.file_path, "utf-8");
+                }
+                catch (err) {
+                    content = `Error reading file: ${err.message}`;
+                }
+                messages.push({
+                    role: "tool",
+                    tool_call_id: toolCall.id,
+                    content: content
+                });
+            }
+            else if (toolCall.type === "function" && toolCall.function.name === "Write") {
+                const args = JSON.parse(toolCall.function.arguments);
+                try {
+                    fs.writeFileSync(args.file_path, args.content);
+                    messages.push({
+                        role: "tool",
+                        tool_call_id: toolCall.id,
+                        content: "File written successfully"
+                    });
+                }
+                catch (err) {
+                    messages.push({
+                        role: "tool",
+                        tool_call_id: toolCall.id,
+                        content: `Error writing file: ${err.message}`
+                    });
+                }
+            }
+            else if (toolCall.type === "function" && toolCall.function.name === "Bash") {
+                const args = JSON.parse(toolCall.function.arguments);
+                try {
+                    const { stdout, stderr } = await exec(args.command);
+                    messages.push({
+                        role: "tool",
+                        tool_call_id: toolCall.id,
+                        content: stdout || stderr || "Command executed successfully"
+                    });
+                }
+                catch (err) {
+                    messages.push({
+                        role: "tool",
+                        tool_call_id: toolCall.id,
+                        content: `Error executing command: ${err.message}`
+                    });
+                }
+            }
+        }
+    }
+}
+main();

package/dist/main.js

@@ -0,0 +1,487 @@
+#!/usr/bin/env node
+import OpenAI from "openai";
+import * as fs from "fs";
+import { exec as execCallback } from "child_process";
+import { promisify } from "util";
+import * as os from "os";
+import * as path from "path";
+import * as readline from "readline";
+import pc from "picocolors";
+const exec = promisify(execCallback);
+const AELA_LOGO = `
+⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⣀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀
+  Aela the Axolotl⠀⠀⠀⠀⢀⡏⠈⢱⠀⠀⡖⠲⣀⠀⠀⠀⠀⠀⠀⠀⠀
+⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⢠⠋⠹⡇⠀⡸⢠⠞⠳⠆⠈⡆⠀⠀⠀⠀⠀⠀⠀
+⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⢀⣠⠤⠤⠤⠤⠤⢬⣇⢀⣿⣚⢳⡏⠀⢰⠃⡴⠛⢦⠀⠀⠀⠀⠀⠀
+⠀⡠⣄⢠⠒⣄⠐⢄⠀⠀⣠⠴⠋⠁⠀⠀⠀⠀⠀⠀⠀⠈⠻⣿⣸⡟⢣⣠⣿⣯⣤⡔⠃⠀⠀⠀⠀⠀⠀
+⠘⣇⠈⢻⡀⠸⡄⠈⣆⠞⠁⠀⠀⠀⠀⠀⠀⠀⣶⣶⣄⡀⠀⠙⠿⣿⣿⣻⡿⠋⢹⠟⠉⡗⠂⠀⠀⠀⠀
+⢴⠚⠢⢤⣿⣧⣽⣶⣏⡀⠀⠀⠀⠀⠀⠀⣀⠀⠘⠿⡭⢯⠆⠐⢲⣿⣾⣿⢁⣶⣏⡠⠞⢳⠉⢩⠏⠀⠀
+⠈⡗⠒⣿⡈⣿⡍⣿⣿⣷⠀⣀⣴⣻⣶⠋⠉⠀⠀⠀⠀⠀⠀⠀⠀⢠⡾⠻⠿⣍⠉⣴⠒⠋⢀⠇⠀⠆⠀
+⢠⠽⠦⠈⣳⣌⣷⣿⠷⠟⠀⠀⠀⠀⠀⠀⠀⠀⣠⢶⡶⢤⣀⠀⢀⡼⠙⣶⣤⠟⠓⠋⠀⠀⠸⡀⠀⢦⠀
+⠘⠂⣤⡔⠛⢯⣙⣿⣆⠀⠀⠀⠀⠀⠀⠀⠀⠀⠈⢧⡃⠀⠈⠙⠛⠓⠒⠛⠦⣀⠀⠀⠀⠀⠀⣇⠀⠘⡀
+⠀⠸⢅⣙⠶⢲⠟⠻⢿⡷⣄⣀⠀⠀⠀⠀⠀⠀⠀⠈⠙⠂⠀⠀⠀⠀⠀⠀⠀⠈⠉⠉⣳⠀⢀⡏⠀⢠⠇
+⠀⠀⠀⠈⠀⠸⠤⠚⠛⠁⢾⠋⠉⠉⠉⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⢀⣀⣴⢛⣉⠴⠛⠀⢀⡞⠀
+⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠙⠒⠒⠦⠴⠦⠶⢤⣀⠀⠀⠀⠀⠀⠀⠀⢠⠿⣍⡉⠁⠀⠀⣀⡤⠊⠀⠀
+⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠈⠙⠲⠦⣄⣀⣀⡤⠴⠒⠚⠋⠉⠉⠉⠁⠀⠀⠀⠀
+`;
+async function promptInput(query) {
+    const rl = readline.createInterface({
+        input: process.stdin,
+        output: process.stdout,
+    });
+    return new Promise((resolve) => rl.question(query, (ans) => {
+        rl.close();
+        resolve(ans);
+    }));
+}
+function getConfigPath() {
+    const configDir = path.join(os.homedir(), ".aela");
+    if (!fs.existsSync(configDir)) {
+        fs.mkdirSync(configDir, { recursive: true });
+    }
+    return path.join(configDir, "config.json");
+}
+function getHistoryPath() {
+    const configDir = path.join(os.homedir(), ".aela");
+    if (!fs.existsSync(configDir)) {
+        fs.mkdirSync(configDir, { recursive: true });
+    }
+    return path.join(configDir, "history.json");
+}
+function loadHistory() {
+    const historyFile = getHistoryPath();
+    if (fs.existsSync(historyFile)) {
+        try {
+            return JSON.parse(fs.readFileSync(historyFile, "utf-8"));
+        }
+        catch (e) {
+            return [];
+        }
+    }
+    return [];
+}
+function saveHistory(messages) {
+    const historyFile = getHistoryPath();
+    const history = messages.filter(m => m.role !== "system").slice(-20);
+    fs.writeFileSync(historyFile, JSON.stringify(history, null, 2));
+}
+function loadConfig() {
+    const configFile = getConfigPath();
+    if (fs.existsSync(configFile)) {
+        try {
+            return JSON.parse(fs.readFileSync(configFile, "utf-8"));
+        }
+        catch (e) {
+            return {};
+        }
+    }
+    return {};
+}
+function saveConfig(config) {
+    const configFile = getConfigPath();
+    fs.writeFileSync(configFile, JSON.stringify(config, null, 2));
+}
+async function getValidConfig() {
+    let config = loadConfig();
+    if (!config.apiKey) {
+        console.log(pc.cyan(AELA_LOGO));
+        const key = await promptInput(pc.green("Please enter your OpenRouter API key: "));
+        config.apiKey = key.trim();
+        saveConfig(config);
+        console.log(pc.green("API Key saved to ~/.aela/config.json\n"));
+    }
+    return config;
+}
+async function main() {
+    const isConfigCommand = process.argv[2] === "config";
+    if (isConfigCommand) {
+        const key = process.argv[3];
+        let value = process.argv[4];
+        if (!key) {
+            console.log("Usage: aela config <key> [value]");
+            console.log("Supported keys: apiKey, model, maxTokens, tavilyApiKey");
+            return;
+        }
+        if (key === "model" && !value) {
+            console.log(pc.dim("Fetching available models from OpenRouter..."));
+            const configObj = await getValidConfig();
+            const apiKey = configObj.apiKey;
+            try {
+                const response = await fetch("https://openrouter.ai/api/v1/models", {
+                    headers: {
+                        "Authorization": `Bearer ${apiKey}`
+                    }
+                });
+                const data = await response.json();
+                const models = data.data.map((m) => m.id);
+                console.log(pc.yellow(pc.bold("\nSelect a model:")));
+                models.forEach((m, i) => console.log(`${pc.cyan(`${i + 1}.`)} ${m}`));
+                const choice = await promptInput(pc.green("Enter the number of the model: "));
+                const index = parseInt(choice, 10) - 1;
+                if (index >= 0 && index < models.length) {
+                    value = models[index];
+                }
+                else {
+                    console.log(pc.red("Invalid choice."));
+                    return;
+                }
+            }
+            catch (e) {
+                console.error(pc.red("Failed to fetch models from OpenRouter. " + e.message));
+                return;
+            }
+        }
+        else if (!value) {
+            console.log(pc.red(`Value is required for ${key}`));
+            return;
+        }
+        if (key === "maxTokens") {
+            value = parseInt(value, 10);
+        }
+        const config = loadConfig();
+        config[key] = value;
+        saveConfig(config);
+        console.log(pc.green(`Successfully updated ${key} to ${value} in ~/.aela/config.json`));
+        return;
+    }
+    const prompt = process.argv.slice(2).join(" ").trim();
+    if (process.argv.length <= 2 || prompt === "" || prompt === "help" || prompt === "--help" || prompt === "-h") {
+        console.log(pc.cyan(AELA_LOGO));
+        console.log(pc.green(pc.bold("Welcome to Aela!")));
+        console.log(pc.yellow("\nAvailable Commands:"));
+        console.log("  aela <your prompt>              - Chat with Aela");
+        console.log("  aela repl                       - Start an interactive REPL session with history");
+        console.log("  aela config model               - Select from a dropdown of available OpenRouter models");
+        console.log("  aela config maxTokens <number>  - Set max completion tokens (e.g. 4000)");
+        console.log("  aela config apiKey <key>        - Set your OpenRouter API key");
+        console.log("  aela config tavilyApiKey <key>  - Set your Tavily API key for web search");
+        console.log("  aela help                       - Show this help message");
+        console.log(pc.yellow("\nExample Usage:"));
+        console.log("  aela Summarize the top 3 stories on https://news.ycombinator.com");
+        console.log("  aela Search the web for the best restaurants in my favorite city");
+        console.log("  aela Read package.json and tell me if any dependencies are outdated");
+        console.log("  aela config model");
+        return;
+    }
+    const config = await getValidConfig();
+    const apiKey = config.apiKey;
+    const modelName = config.model || "anthropic/claude-haiku-4.5";
+    const maxTokens = config.maxTokens || 4000;
+    const baseURL = process.env.OPENROUTER_BASE_URL ?? "https://openrouter.ai/api/v1";
+    const client = new OpenAI({
+        apiKey: apiKey,
+        baseURL: baseURL,
+    });
+    const systemPrompt = `You are Aela, a helpful terminal-based AI assistant.
+The current date and time is: ${new Date().toLocaleString()}.
+You are running on: ${os.type()} ${os.release()} (${os.arch()}).
+Use your tools to help the user. If they ask about current time or dates, you can use the time provided above.
+IMPORTANT: If you need to ask the user a clarifying question or request permission, you MUST use the "AskUser" tool. Do not just output the question as text, because the program will exit immediately and you will not get an answer.`;
+    const messages = [
+        { role: "system", content: systemPrompt },
+        { role: "user", content: prompt }
+    ];
+    const tools = [{
+            "type": "function",
+            "function": {
+                "name": "Read",
+                "description": "Read and return the contents of a file",
+                "parameters": {
+                    "type": "object",
+                    "properties": {
+                        "file_path": {
+                            "type": "string",
+                            "description": "The path to the file to read"
+                        }
+                    },
+                    "required": ["file_path"]
+                }
+            }
+        },
+        {
+            "type": "function",
+            "function": {
+                "name": "Write",
+                "description": "Write content to a file",
+                "parameters": {
+                    "type": "object",
+                    "required": ["file_path", "content"],
+                    "properties": {
+                        "file_path": {
+                            "type": "string",
+                            "description": "The path of the file to write to"
+                        },
+                        "content": {
+                            "type": "string",
+                            "description": "The content to write to the file"
+                        }
+                    }
+                }
+            }
+        },
+        {
+            "type": "function",
+            "function": {
+                "name": "Bash",
+                "description": "Execute a shell command",
+                "parameters": {
+                    "type": "object",
+                    "required": ["command"],
+                    "properties": {
+                        "command": {
+                            "type": "string",
+                            "description": "The command to execute"
+                        }
+                    }
+                }
+            }
+        },
+        {
+            "type": "function",
+            "function": {
+                "name": "SearchWeb",
+                "description": "Search the web for information using Tavily API. Useful for current events, facts, and finding documentation.",
+                "parameters": {
+                    "type": "object",
+                    "required": ["query"],
+                    "properties": {
+                        "query": {
+                            "type": "string",
+                            "description": "The search query"
+                        }
+                    }
+                }
+            }
+        },
+        {
+            "type": "function",
+            "function": {
+                "name": "AskUser",
+                "description": "Pause execution and ask the user a question to get clarification or permission.",
+                "parameters": {
+                    "type": "object",
+                    "required": ["question"],
+                    "properties": {
+                        "question": {
+                            "type": "string",
+                            "description": "The question to ask the user"
+                        }
+                    }
+                }
+            }
+        },
+        {
+            "type": "function",
+            "function": {
+                "name": "FetchURL",
+                "description": "Fetch the raw text content of a URL.",
+                "parameters": {
+                    "type": "object",
+                    "required": ["url"],
+                    "properties": {
+                        "url": {
+                            "type": "string",
+                            "description": "The URL to fetch"
+                        }
+                    }
+                }
+            }
+        }];
+    async function runAgent(client, modelName, messages, maxTokens, tools, config) {
+        while (true) {
+            let response;
+            try {
+                response = await client.chat.completions.create({
+                    model: modelName,
+                    messages: messages,
+                    max_completion_tokens: maxTokens,
+                    tools: tools
+                });
+            }
+            catch (e) {
+                if (e.status === 402) {
+                    console.error(`\nError: Not enough credits for this request.`);
+                    console.error(`You requested up to ${maxTokens} max_tokens, which exceeds your available balance.`);
+                    console.error(`Try lowering your maxTokens limit by running:`);
+                    console.error(`  aela config maxTokens <number>\n`);
+                    process.exit(1);
+                }
+                throw e;
+            }
+            if (!response.choices || response.choices.length === 0) {
+                throw new Error("no choices in response");
+            }
+            const message = response.choices[0].message;
+            messages.push(message);
+            if (!message.tool_calls || message.tool_calls.length === 0) {
+                if (message.content) {
+                    console.log(pc.cyan(message.content));
+                }
+                break;
+            }
+            for (const toolCall of message.tool_calls) {
+                if (toolCall.type === "function" && toolCall.function.name === "Read") {
+                    const args = JSON.parse(toolCall.function.arguments);
+                    let content = "";
+                    try {
+                        content = fs.readFileSync(args.file_path, "utf-8");
+                    }
+                    catch (err) {
+                        content = `Error reading file: ${err.message}`;
+                    }
+                    messages.push({
+                        role: "tool",
+                        tool_call_id: toolCall.id,
+                        content: content
+                    });
+                }
+                else if (toolCall.type === "function" && toolCall.function.name === "Write") {
+                    const args = JSON.parse(toolCall.function.arguments);
+                    try {
+                        fs.writeFileSync(args.file_path, args.content);
+                        messages.push({
+                            role: "tool",
+                            tool_call_id: toolCall.id,
+                            content: "File written successfully"
+                        });
+                    }
+                    catch (err) {
+                        messages.push({
+                            role: "tool",
+                            tool_call_id: toolCall.id,
+                            content: `Error writing file: ${err.message}`
+                        });
+                    }
+                }
+                else if (toolCall.type === "function" && toolCall.function.name === "Bash") {
+                    const args = JSON.parse(toolCall.function.arguments);
+                    try {
+                        const { stdout, stderr } = await exec(args.command);
+                        messages.push({
+                            role: "tool",
+                            tool_call_id: toolCall.id,
+                            content: stdout || stderr || "Command executed successfully"
+                        });
+                    }
+                    catch (err) {
+                        messages.push({
+                            role: "tool",
+                            tool_call_id: toolCall.id,
+                            content: `Error executing command: ${err.message}`
+                        });
+                    }
+                }
+                else if (toolCall.type === "function" && toolCall.function.name === "SearchWeb") {
+                    const args = JSON.parse(toolCall.function.arguments);
+                    if (!config.tavilyApiKey) {
+                        messages.push({
+                            role: "tool",
+                            tool_call_id: toolCall.id,
+                            content: "Error: tavilyApiKey is not configured. Please tell the user to run 'aela config tavilyApiKey <their-tavily-api-key>' to enable web search."
+                        });
+                    }
+                    else {
+                        try {
+                            const searchResponse = await fetch("https://api.tavily.com/search", {
+                                method: "POST",
+                                headers: {
+                                    "Content-Type": "application/json"
+                                },
+                                body: JSON.stringify({
+                                    api_key: config.tavilyApiKey,
+                                    query: args.query,
+                                    search_depth: "basic",
+                                    include_answer: true
+                                })
+                            });
+                            const searchData = await searchResponse.json();
+                            let content = "";
+                            if (searchData.answer) {
+                                content += `Answer: ${searchData.answer}\n\n`;
+                            }
+                            if (searchData.results && searchData.results.length > 0) {
+                                content += "Sources:\n" + searchData.results.map((r) => `- ${r.title} (${r.url}): ${r.content}`).join("\n");
+                            }
+                            else {
+                                content += "No search results found.";
+                            }
+                            messages.push({
+                                role: "tool",
+                                tool_call_id: toolCall.id,
+                                content: content || "No relevant info found."
+                            });
+                        }
+                        catch (err) {
+                            messages.push({
+                                role: "tool",
+                                tool_call_id: toolCall.id,
+                                content: `Error executing web search: ${err.message}`
+                            });
+                        }
+                    }
+                }
+                else if (toolCall.type === "function" && toolCall.function.name === "AskUser") {
+                    const args = JSON.parse(toolCall.function.arguments);
+                    const answer = await promptInput(`\n${pc.yellow(pc.bold("[Aela asks]:"))} ${pc.yellow(args.question)}\n${pc.dim("Your answer: ")}`);
+                    messages.push({
+                        role: "tool",
+                        tool_call_id: toolCall.id,
+                        content: answer
+                    });
+                }
+                else if (toolCall.type === "function" && toolCall.function.name === "FetchURL") {
+                    const args = JSON.parse(toolCall.function.arguments);
+                    try {
+                        const response = await fetch(args.url);
+                        let text = await response.text();
+                        text = text.replace(/<style[^>]*>[\s\S]*?<\/style>/gi, '')
+                            .replace(/<script[^>]*>[\s\S]*?<\/script>/gi, '')
+                            .replace(/<[^>]+>/g, ' ')
+                            .replace(/\s+/g, ' ')
+                            .trim();
+                        messages.push({
+                            role: "tool",
+                            tool_call_id: toolCall.id,
+                            content: text.slice(0, 10000)
+                        });
+                    }
+                    catch (err) {
+                        messages.push({
+                            role: "tool",
+                            tool_call_id: toolCall.id,
+                            content: `Error fetching URL: ${err.message}`
+                        });
+                    }
+                }
+            }
+        }
+    }
+    if (prompt === "repl") {
+        console.log(pc.cyan(AELA_LOGO));
+        console.log(pc.green(pc.bold("Welcome to Aela REPL!")) + " " + pc.dim("Type 'exit' to quit.\n"));
+        let messages = loadHistory();
+        if (messages.length === 0 || messages[0].role !== "system") {
+            messages.unshift({ role: "system", content: systemPrompt });
+        }
+        else {
+            messages[0].content = systemPrompt;
+        }
+        while (true) {
+            const userInput = await promptInput(pc.green(pc.bold("You: ")));
+            if (userInput.trim().toLowerCase() === "exit" || userInput.trim() === "") {
+                break;
+            }
+            messages.push({ role: "user", content: userInput });
+            await runAgent(client, modelName, messages, maxTokens, tools, config);
+            saveHistory(messages);
+        }
+    }
+    else {
+        const messages = [
+            { role: "system", content: systemPrompt },
+            { role: "user", content: prompt }
+        ];
+        await runAgent(client, modelName, messages, maxTokens, tools, config);
+    }
+}
+main();

package/package.json

@@ -0,0 +1,41 @@
+{
+  "name": "aela-ai",
+  "version": "1.0.0",
+  "description": "An agentic, terminal-based AI assistant with file access, web search, and persistent REPL mode.",
+  "type": "module",
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/ABHIGYAN-MOHANTA/aela.git"
+  },
+  "keywords": [
+    "cli",
+    "ai",
+    "agent",
+    "terminal",
+    "openrouter",
+    "llm",
+    "tavily"
+  ],
+  "files": [
+    "dist",
+    "image.png",
+    "README.md"
+  ],
+  "bin": {
+    "aela": "./dist/main.js"
+  },
+  "scripts": {
+    "dev": "bun run app/main.ts",
+    "build": "tsc"
+  },
+  "dependencies": {
+    "openai": "^6.16.0",
+    "picocolors": "^1.1.1"
+  },
+  "devDependencies": {
+    "@types/bun": "latest",
+    "@types/node": "latest",
+    "typescript": "latest"
+  }
+}