autoclaw 1.0.39 → 1.1.0

package/LICENSE

@@ -1,21 +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.
+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

@@ -189,3 +189,13 @@ Contributions are welcome! Please feel free to submit a Pull Request.
 
 ---
 GitHub: [https://github.com/tsingliuwin/autoclaw](https://github.com/tsingliuwin/autoclaw)
+
+## Star History
+
+<a href="https://www.star-history.com/?repos=tsingliuwin%2Fautoclaw&type=date&legend=top-left">
+ <picture>
+   <source media="(prefers-color-scheme: dark)" srcset="https://api.star-history.com/chart?repos=tsingliuwin/autoclaw&type=date&theme=dark&legend=top-left" />
+   <source media="(prefers-color-scheme: light)" srcset="https://api.star-history.com/chart?repos=tsingliuwin/autoclaw&type=date&legend=top-left" />
+   <img alt="Star History Chart" src="https://api.star-history.com/chart?repos=tsingliuwin/autoclaw&type=date&legend=top-left" />
+ </picture>
+</a>

package/README.zh-CN.md

@@ -1,192 +1,192 @@
-# AutoClaw 🦞
-
-[![NPM Version](https://img.shields.io/npm/v/autoclaw.svg?style=flat-square)](https://www.npmjs.com/package/autoclaw)
-[![NPM Downloads](https://img.shields.io/npm/dm/autoclaw.svg?style=flat-square)](https://www.npmjs.com/package/autoclaw)
-[![GitHub](https://img.shields.io/badge/GitHub-Repository-blue?logo=github&style=flat-square)](https://github.com/tsingliuwin/autoclaw)
-[![License](https://img.shields.io/npm/l/autoclaw.svg?style=flat-square)](https://github.com/tsingliuwin/autoclaw/blob/main/LICENSE)
-[![PRs Welcome](https://img.shields.io/badge/PRs-welcome-brightgreen.svg?style=flat-square)](http://makeapullrequest.com)
-
-**稳定、高工程化、易规模化：专为无界面系统设计的高效自动化 Agent 框架。**
-
-[English](./README.md) | 简体中文
-
----
-
-🔗 **GitHub 仓库**: [https://github.com/tsingliuwin/autoclaw](https://github.com/tsingliuwin/autoclaw)
-
----
-
-AutoClaw 是一款针对 **“无界面系统” (Headless Systems)** 的高稳定性自动化 Agent 开源框架。
-
-相比于 OpenClaw 等需要“看屏幕”的 Agent（如视觉解析），AutoClaw 采用纯指令驱动，具有更强的**工程化**属性、更高的**稳定性**，以及极易**规模化**的特点。它专为在各种复杂环境中执行确定性的自动化任务而设计——无论是本地服务器、CI/CD 流水线，还是成千上万个容器节点。
-
-## 为什么选择 AutoClaw?
-
-- 🐳 **Docker 友好**: 专为容器化环境设计，无 GUI 依赖，极致轻量（Node.js/Alpine 友好）。
-- 🚀 **更强工程化 (Better Engineering)**: 并非依赖不稳定的视觉识别，而是通过系统 API 和 Shell 指令精准操作，确保任务执行的确定性。
-- 🛡️ **高稳定性 (Superior Stability)**: 摆脱了图形界面渲染、屏幕分辨率、网络延迟对视觉识别的影响，即便在极端的 Headless 环境下也能稳定运行。
-- 📈 **易于规模化 (Massive Scalability)**: 低资源占用使得你可以同时编排成千上万个 Agent 实例（如在 Kubernetes 集群中），实现真正的自动化蜂群。
-- 🔌 **集群就绪 (Swarm Ready)**: 无状态设计，支持通过 K8s、Docker Swarm 或简单的 Shell 脚本进行大规模调度。
-- 🧩 **可扩展集成**: 内置支持网页搜索 (Tavily)、邮件发送 (SMTP) 以及通知钩子 (飞书、钉钉、企业微信)。
-
-## 特性
-
-- 📜 **无头执行 (Headless Execution)**: 真正的无头模式，无需浏览器或图形化界面。
-- 🤖 **非交互模式**: 支持自动化标志（`-y`, `--no-interactive`），完美适配零干预的自动化流程。
-- 📂 **全方位控制 (Universal Control)**: 从基础的文件 I/O 到复杂的系统管理与代码重构。
-- 🧠 **上下文感知 (Context Aware)**: 自动识别操作系统与容器环境，并提供精确的系统时间以处理相对时间查询。
-- 🌐 **网页搜索**: 集成 Tavily，支持实时信息检索。
-- 🕒 **时间精准**: 内置工具获取精确系统日期和时间，确保正确的时间上下文。
-- 📧 **通讯能力**: 自动发送电子邮件并将通知推送至聊天群组。
-
-## 技术栈
-- **运行时**: Node.js
-- **语言**: TypeScript
-- **框架**: Commander.js
-- **UI**: Inquirer (交互), Chalk (样式), Ora (加载动画)
-- **AI**: OpenAI SDK (兼容 DeepSeek, LocalLLM 等)
-
-## 安装
-
-### 用户安装
-通过 npm 全局安装：
-```bash
-npm install -g autoclaw
-```
-
-### 开发安装
-1.  克隆仓库：
-    ```bash
-    git clone https://github.com/tsingliuwin/autoclaw.git
-    cd autoclaw
-    ```
-2.  安装依赖：
-    ```bash
-    npm install
-    ```
-3.  构建项目：
-    ```bash
-    npm run build
-    ```
-4.  全局链接 (可选)：
-    ```bash
-    npm link
-    ```
-
-## 快速上手
-
-1.  **配置**: 运行交互式设置向导以配置您的 API 密钥和集成插件。
-    ```bash
-    autoclaw setup
-    ```
-2.  **运行**: 在交互模式下启动 Agent。
-    ```bash
-    autoclaw
-    ```
-
-## 使用方法
-
-### 交互模式
-直接运行 `autoclaw` 进入对话循环。
-```bash
-autoclaw
-> 列出 src 文件夹中所有的 TypeScript 文件。
-```
-
-### 无头模式 (一次性任务)
-执行单个指令后立即退出。
-```bash
-autoclaw "检查磁盘使用情况并将报告保存到 usage.txt" --no-interactive
-```
-
-### 自动确认 (CI/CD)
-自动批准所有工具执行（危险操作，请谨慎使用或在沙箱环境下运行）。
-```bash
-autoclaw "将 src/index.ts 重构为使用 ES 模块" -y
-```
-
-### CLI 选项
-- `-m, --model <model>`: 指定 LLM 模型 (默认: `gpt-4o`)。
-- `-n, --no-interactive`: 处理完初始查询后退出 (无头模式)。
-- `-y, --yes`: 自动确认所有工具执行 (例如 Shell 命令)。
-
-## 配置
-
-AutoClaw 使用层级配置系统。
-
-**优先级排序 (从高到低):**
-1.  **CLI 参数**: (例如 `-m gpt-4o`)
-2.  **环境变量**: (`OPENAI_API_KEY`, `.env` 文件)
-3.  **项目配置**: (当前目录下的 `./.autoclaw/setting.json`)
-4.  **全局配置**: (`~/.autoclaw/setting.json`)
-
-### 支持的配置键 (JSON)
-- `apiKey`: 您的 OpenAI API 密钥。
-- `baseUrl`: 自定义 API 基础地址 (例如 DeepSeek 或本地 LLM)。
-- `model`: 默认使用的模型。
-- `tavilyApiKey`: Tavily 网页搜索的 API 密钥。
-- `smtpHost`, `smtpPort`, `smtpUser`, `smtpPass`, `smtpFrom`: SMTP 邮件设置。
-- `feishuWebhook`, `dingtalkWebhook`, `wecomWebhook`: 通知钩子地址。
-
-### 项目级配置示例
-在 `.autoclaw/setting.json` 创建文件：
-```json
-{
-  "model": "gpt-3.5-turbo",
-  "baseUrl": "https://api.deepseek.com/v1"
-}
-```
-
-> **⚠️ 安全警告**: 如果您在 `.autoclaw/setting.json` 中存储了 `apiKey` 或机密信息，请务必将 `.autoclaw/` 添加到您的 `.gitignore` 文件中，以防泄露！
-
-## 集成功能
-
-### 网页搜索 (Tavily)
-如果您在设置中提供了 Tavily API 密钥，AutoClaw 可以搜索网页。
-- **示例**: "搜索最新的 Node.js 发布说明。"
-
-### 邮件 (SMTP)
-配置 SMTP 设置以允许 Agent 发送邮件。
-- **示例**: "向 user@example.com 发送一封包含日志文件摘要的邮件。"
-
-### 通知 (飞书/钉钉/企业微信)
-配置 Webhook 以在团队聊天应用中接收警报或报告。
-- **示例**: "在飞书上通知团队构建已完成。"
-
-### 日期与时间
-内置工具为 Agent 提供当前系统时间，确保准确处理相对时间请求。
-- **示例**: "今天是几号？" 或 "提醒我下周一检查日志。"
-
-## Docker 支持
-
-### 截图中的中文显示问题
-在 Docker 容器（尤其是 Alpine 或 Debian Slim）中运行时，网页截图中的中文可能会显示为方块（"豆腐块"）。表情符号（如 🔥）也可能显示为方块。
-
-**解决方案:** 在容器中安装 CJK（中日韩）和 Emoji 字体。
-
-**Debian/Ubuntu:**
-```bash
-apt-get update && apt-get install -y fonts-noto-cjk fonts-wqy-zenhei fonts-noto-color-emoji
-```
-
-**Alpine Linux:**
-```bash
-apk add font-noto-cjk font-noto-emoji
-```
-
-## 开源协议
-
-MIT
-
-## 贡献指南
-
-欢迎贡献！请随时提交 Pull Request。
-
-1.  Fork 本项目
-2.  创建您的特性分支 (`git checkout -b feature/AmazingFeature`)
-3.  提交您的更改 (`git commit -m 'Add some AmazingFeature'`)
-4.  推送至分支 (`git push origin feature/AmazingFeature`)
-5.  开启一个 Pull Request
-
----
+# AutoClaw 🦞
+
+[![NPM Version](https://img.shields.io/npm/v/autoclaw.svg?style=flat-square)](https://www.npmjs.com/package/autoclaw)
+[![NPM Downloads](https://img.shields.io/npm/dm/autoclaw.svg?style=flat-square)](https://www.npmjs.com/package/autoclaw)
+[![GitHub](https://img.shields.io/badge/GitHub-Repository-blue?logo=github&style=flat-square)](https://github.com/tsingliuwin/autoclaw)
+[![License](https://img.shields.io/npm/l/autoclaw.svg?style=flat-square)](https://github.com/tsingliuwin/autoclaw/blob/main/LICENSE)
+[![PRs Welcome](https://img.shields.io/badge/PRs-welcome-brightgreen.svg?style=flat-square)](http://makeapullrequest.com)
+
+**稳定、高工程化、易规模化：专为无界面系统设计的高效自动化 Agent 框架。**
+
+[English](./README.md) | 简体中文
+
+---
+
+🔗 **GitHub 仓库**: [https://github.com/tsingliuwin/autoclaw](https://github.com/tsingliuwin/autoclaw)
+
+---
+
+AutoClaw 是一款针对 **“无界面系统” (Headless Systems)** 的高稳定性自动化 Agent 开源框架。
+
+相比于 OpenClaw 等需要“看屏幕”的 Agent（如视觉解析），AutoClaw 采用纯指令驱动，具有更强的**工程化**属性、更高的**稳定性**，以及极易**规模化**的特点。它专为在各种复杂环境中执行确定性的自动化任务而设计——无论是本地服务器、CI/CD 流水线，还是成千上万个容器节点。
+
+## 为什么选择 AutoClaw?
+
+- 🐳 **Docker 友好**: 专为容器化环境设计，无 GUI 依赖，极致轻量（Node.js/Alpine 友好）。
+- 🚀 **更强工程化 (Better Engineering)**: 并非依赖不稳定的视觉识别，而是通过系统 API 和 Shell 指令精准操作，确保任务执行的确定性。
+- 🛡️ **高稳定性 (Superior Stability)**: 摆脱了图形界面渲染、屏幕分辨率、网络延迟对视觉识别的影响，即便在极端的 Headless 环境下也能稳定运行。
+- 📈 **易于规模化 (Massive Scalability)**: 低资源占用使得你可以同时编排成千上万个 Agent 实例（如在 Kubernetes 集群中），实现真正的自动化蜂群。
+- 🔌 **集群就绪 (Swarm Ready)**: 无状态设计，支持通过 K8s、Docker Swarm 或简单的 Shell 脚本进行大规模调度。
+- 🧩 **可扩展集成**: 内置支持网页搜索 (Tavily)、邮件发送 (SMTP) 以及通知钩子 (飞书、钉钉、企业微信)。
+
+## 特性
+
+- 📜 **无头执行 (Headless Execution)**: 真正的无头模式，无需浏览器或图形化界面。
+- 🤖 **非交互模式**: 支持自动化标志（`-y`, `--no-interactive`），完美适配零干预的自动化流程。
+- 📂 **全方位控制 (Universal Control)**: 从基础的文件 I/O 到复杂的系统管理与代码重构。
+- 🧠 **上下文感知 (Context Aware)**: 自动识别操作系统与容器环境，并提供精确的系统时间以处理相对时间查询。
+- 🌐 **网页搜索**: 集成 Tavily，支持实时信息检索。
+- 🕒 **时间精准**: 内置工具获取精确系统日期和时间，确保正确的时间上下文。
+- 📧 **通讯能力**: 自动发送电子邮件并将通知推送至聊天群组。
+
+## 技术栈
+- **运行时**: Node.js
+- **语言**: TypeScript
+- **框架**: Commander.js
+- **UI**: Inquirer (交互), Chalk (样式), Ora (加载动画)
+- **AI**: OpenAI SDK (兼容 DeepSeek, LocalLLM 等)
+
+## 安装
+
+### 用户安装
+通过 npm 全局安装：
+```bash
+npm install -g autoclaw
+```
+
+### 开发安装
+1.  克隆仓库：
+    ```bash
+    git clone https://github.com/tsingliuwin/autoclaw.git
+    cd autoclaw
+    ```
+2.  安装依赖：
+    ```bash
+    npm install
+    ```
+3.  构建项目：
+    ```bash
+    npm run build
+    ```
+4.  全局链接 (可选)：
+    ```bash
+    npm link
+    ```
+
+## 快速上手
+
+1.  **配置**: 运行交互式设置向导以配置您的 API 密钥和集成插件。
+    ```bash
+    autoclaw setup
+    ```
+2.  **运行**: 在交互模式下启动 Agent。
+    ```bash
+    autoclaw
+    ```
+
+## 使用方法
+
+### 交互模式
+直接运行 `autoclaw` 进入对话循环。
+```bash
+autoclaw
+> 列出 src 文件夹中所有的 TypeScript 文件。
+```
+
+### 无头模式 (一次性任务)
+执行单个指令后立即退出。
+```bash
+autoclaw "检查磁盘使用情况并将报告保存到 usage.txt" --no-interactive
+```
+
+### 自动确认 (CI/CD)
+自动批准所有工具执行（危险操作，请谨慎使用或在沙箱环境下运行）。
+```bash
+autoclaw "将 src/index.ts 重构为使用 ES 模块" -y
+```
+
+### CLI 选项
+- `-m, --model <model>`: 指定 LLM 模型 (默认: `gpt-4o`)。
+- `-n, --no-interactive`: 处理完初始查询后退出 (无头模式)。
+- `-y, --yes`: 自动确认所有工具执行 (例如 Shell 命令)。
+
+## 配置
+
+AutoClaw 使用层级配置系统。
+
+**优先级排序 (从高到低):**
+1.  **CLI 参数**: (例如 `-m gpt-4o`)
+2.  **环境变量**: (`OPENAI_API_KEY`, `.env` 文件)
+3.  **项目配置**: (当前目录下的 `./.autoclaw/setting.json`)
+4.  **全局配置**: (`~/.autoclaw/setting.json`)
+
+### 支持的配置键 (JSON)
+- `apiKey`: 您的 OpenAI API 密钥。
+- `baseUrl`: 自定义 API 基础地址 (例如 DeepSeek 或本地 LLM)。
+- `model`: 默认使用的模型。
+- `tavilyApiKey`: Tavily 网页搜索的 API 密钥。
+- `smtpHost`, `smtpPort`, `smtpUser`, `smtpPass`, `smtpFrom`: SMTP 邮件设置。
+- `feishuWebhook`, `dingtalkWebhook`, `wecomWebhook`: 通知钩子地址。
+
+### 项目级配置示例
+在 `.autoclaw/setting.json` 创建文件：
+```json
+{
+  "model": "gpt-3.5-turbo",
+  "baseUrl": "https://api.deepseek.com/v1"
+}
+```
+
+> **⚠️ 安全警告**: 如果您在 `.autoclaw/setting.json` 中存储了 `apiKey` 或机密信息，请务必将 `.autoclaw/` 添加到您的 `.gitignore` 文件中，以防泄露！
+
+## 集成功能
+
+### 网页搜索 (Tavily)
+如果您在设置中提供了 Tavily API 密钥，AutoClaw 可以搜索网页。
+- **示例**: "搜索最新的 Node.js 发布说明。"
+
+### 邮件 (SMTP)
+配置 SMTP 设置以允许 Agent 发送邮件。
+- **示例**: "向 user@example.com 发送一封包含日志文件摘要的邮件。"
+
+### 通知 (飞书/钉钉/企业微信)
+配置 Webhook 以在团队聊天应用中接收警报或报告。
+- **示例**: "在飞书上通知团队构建已完成。"
+
+### 日期与时间
+内置工具为 Agent 提供当前系统时间，确保准确处理相对时间请求。
+- **示例**: "今天是几号？" 或 "提醒我下周一检查日志。"
+
+## Docker 支持
+
+### 截图中的中文显示问题
+在 Docker 容器（尤其是 Alpine 或 Debian Slim）中运行时，网页截图中的中文可能会显示为方块（"豆腐块"）。表情符号（如 🔥）也可能显示为方块。
+
+**解决方案:** 在容器中安装 CJK（中日韩）和 Emoji 字体。
+
+**Debian/Ubuntu:**
+```bash
+apt-get update && apt-get install -y fonts-noto-cjk fonts-wqy-zenhei fonts-noto-color-emoji
+```
+
+**Alpine Linux:**
+```bash
+apk add font-noto-cjk font-noto-emoji
+```
+
+## 开源协议
+
+MIT
+
+## 贡献指南
+
+欢迎贡献！请随时提交 Pull Request。
+
+1.  Fork 本项目
+2.  创建您的特性分支 (`git checkout -b feature/AmazingFeature`)
+3.  提交您的更改 (`git commit -m 'Add some AmazingFeature'`)
+4.  推送至分支 (`git push origin feature/AmazingFeature`)
+5.  开启一个 Pull Request
+
+---
 GitHub: [https://github.com/tsingliuwin/autoclaw](https://github.com/tsingliuwin/autoclaw)

package/dist/agent.js

@@ -1,13 +1,16 @@
 import OpenAI from 'openai';
 import chalk from 'chalk';
 import ora from 'ora';
+import * as fs from 'fs';
 import * as os from 'os';
+import * as path from 'path';
 import { getToolDefinitions, executeToolHandler } from './tools/index.js';
 export class Agent {
     client;
     messages;
     model;
     config;
+    lastOutputFile = null;
     constructor(apiKey, baseURL, model = 'gpt-4-turbo-preview', config = {}) {
         this.client = new OpenAI({
             apiKey: apiKey,
@@ -28,8 +31,9 @@ System Information:
         this.messages = [
             {
                 role: "system",
-                content: `You are AutoClaw, a Docker-Native Autonomous Agent designed for massive scale automation.
-You are likely running inside a container or headless server, possibly as one of thousands of parallel units in a swarm.
+                content: `You are AutoClaw, an engineering-first headless agent framework designed for stable, scalable automation.
+You operate through precise command-driven execution rather than visual interpretation, ensuring deterministic and reproducible outcomes.
+You may run on a local workstation, a headless server, inside a Docker container, or as part of a larger automated pipeline.
 
 CONTEXT:
 ${systemInfo}
@@ -55,27 +59,140 @@ GUIDELINES:
         while (active) {
             const spinner = ora('Thinking...').start();
             try {
-                const response = await this.client.chat.completions.create({
+                const stream = await this.client.chat.completions.create({
                     model: this.model,
                     messages: this.messages,
                     tools: getToolDefinitions(),
-                    tool_choice: "auto"
+                    tool_choice: "auto",
+                    stream: true
                 });
-                spinner.stop();
-                const message = response.choices[0].message;
-                this.messages.push(message);
-                if (message.content) {
-                    console.log(chalk.blue("AutoClaw: ") + message.content);
+                let content = '';
+                let reasoningContent = '';
+                let toolCalls = [];
+                let contentStarted = false;
+                let reasoningStarted = false;
+                const toolNamesSeen = new Set();
+                for await (const chunk of stream) {
+                    const delta = chunk.choices[0]?.delta;
+                    // Handle reasoning/thinking content (e.g., DeepSeek)
+                    if (delta?.reasoning_content) {
+                        if (!reasoningStarted) {
+                            spinner.stop();
+                            process.stdout.write(chalk.dim('\n[Thinking] '));
+                            reasoningStarted = true;
+                        }
+                        process.stdout.write(chalk.dim(delta.reasoning_content));
+                        reasoningContent += delta.reasoning_content;
+                    }
+                    // Handle regular content
+                    if (delta?.content) {
+                        if (!contentStarted) {
+                            spinner.stop();
+                            if (reasoningStarted)
+                                process.stdout.write('\n');
+                            process.stdout.write(chalk.blue("AutoClaw: "));
+                            contentStarted = true;
+                        }
+                        process.stdout.write(delta.content);
+                        content += delta.content;
+                    }
+                    // Handle tool calls - show name as soon as available
+                    if (delta?.tool_calls) {
+                        for (const tc of delta.tool_calls) {
+                            const idx = tc.index;
+                            if (!toolCalls[idx]) {
+                                toolCalls[idx] = { id: tc.id || '', type: 'function', function: { name: '', arguments: '' } };
+                            }
+                            if (tc.id)
+                                toolCalls[idx].id = tc.id;
+                            if (tc.function?.name)
+                                toolCalls[idx].function.name += tc.function.name;
+                            if (tc.function?.arguments)
+                                toolCalls[idx].function.arguments += tc.function.arguments;
+                            // Show tool name as soon as it's complete
+                            if (tc.function?.name && !toolNamesSeen.has(idx)) {
+                                toolNamesSeen.add(idx);
+                                spinner.stop();
+                                if (contentStarted)
+                                    process.stdout.write('\n');
+                                if (reasoningStarted && !contentStarted)
+                                    process.stdout.write('\n');
+                                process.stdout.write(chalk.cyan(`[Calling] ${tc.function.name}\n`));
+                            }
+                        }
+                    }
+                }
+                if (reasoningStarted) {
+                    console.log(); // newline after reasoning
                 }
-                if (message.tool_calls) {
-                    for (const toolCall of message.tool_calls) {
+                if (contentStarted) {
+                    console.log(); // newline after streamed content
+                }
+                if (!reasoningStarted && !contentStarted) {
+                    spinner.stop();
+                }
+                // Build the full message for history
+                const message = { role: "assistant" };
+                if (content)
+                    message.content = content;
+                if (reasoningContent)
+                    message.reasoning_content = reasoningContent;
+                if (toolCalls.length > 0) {
+                    message.tool_calls = toolCalls;
+                    message.content = message.content || null;
+                }
+                this.messages.push(message);
+                if (toolCalls.length > 0) {
+                    for (const toolCall of toolCalls) {
                         if (toolCall.type !== 'function')
                             continue;
                         const functionName = toolCall.function.name;
                         const functionArgs = JSON.parse(toolCall.function.arguments);
-                        console.log(chalk.gray(`Executing tool: ${functionName}...`));
-                        // Pass the full config to the tool handler
-                        const toolResult = await executeToolHandler(functionName, functionArgs, this.config);
+                        // Display tool call info
+                        console.log(chalk.cyan(`\n[Tool] ${functionName}`));
+                        const argsStr = JSON.stringify(functionArgs, null, 2);
+                        const argsLines = argsStr.split('\n');
+                        if (argsLines.length > 8) {
+                            console.log(chalk.dim(argsLines.slice(0, 8).join('\n')));
+                            console.log(chalk.dim(`  ... (${argsLines.length - 8} more lines)`));
+                        }
+                        else {
+                            console.log(chalk.dim(argsStr));
+                        }
+                        const execSpinner = ora('Executing...').start();
+                        let toolResult;
+                        try {
+                            toolResult = await executeToolHandler(functionName, functionArgs, this.config);
+                            execSpinner.stop();
+                        }
+                        catch (err) {
+                            execSpinner.fail('Tool execution failed');
+                            toolResult = `Error: ${err.message}`;
+                        }
+                        // Display result with folding for long output
+                        const MAX_PREVIEW_LINES = 20;
+                        const resultLines = toolResult.split('\n');
+                        console.log(chalk.green(`[Result]`));
+                        if (resultLines.length > MAX_PREVIEW_LINES) {
+                            // Show preview
+                            console.log(resultLines.slice(0, MAX_PREVIEW_LINES).join('\n'));
+                            const remaining = resultLines.length - MAX_PREVIEW_LINES;
+                            console.log(chalk.dim(`\n  ... ${remaining} more lines (${resultLines.length} lines total)`));
+                            // Save full output to file
+                            const outputDir = path.join(os.homedir(), '.autoclaw', 'output');
+                            if (!fs.existsSync(outputDir)) {
+                                fs.mkdirSync(outputDir, { recursive: true });
+                            }
+                            const ts = new Date().toISOString().replace(/[:.]/g, '-');
+                            const outputFile = path.join(outputDir, `${functionName}_${ts}.txt`);
+                            fs.writeFileSync(outputFile, toolResult, 'utf-8');
+                            this.lastOutputFile = outputFile;
+                            console.log(chalk.dim(`  Type '/view' to see full output`));
+                        }
+                        else {
+                            console.log(toolResult);
+                            this.lastOutputFile = null;
+                        }
                         this.messages.push({
                             role: "tool",
                             tool_call_id: toolCall.id,

package/dist/index.js

@@ -9,6 +9,7 @@ import * as path from 'path';
 import * as os from 'os';
 import * as readline from 'node:readline/promises';
 import { fileURLToPath } from 'url';
+import { spawn } from 'child_process';
 // Handle Ctrl+C gracefully
 function handleExit() {
     console.log(chalk.cyan("\n\nGoodbye! (Interrupted)"));
@@ -23,6 +24,7 @@ process.on('SIGTERM', handleExit);
 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');
+const GLOBAL_ENV_FILE = path.join(GLOBAL_CONFIG_DIR, '.env');
 function loadJsonConfig(filePath) {
     if (fs.existsSync(filePath)) {
         try {
@@ -34,8 +36,9 @@ function loadJsonConfig(filePath) {
     }
     return {};
 }
-// Load local env vars (lowest priority of env vars, but env vars override JSON)
-dotenv.config();
+// Load env vars only from AutoClaw's own config directory to avoid
+// unrelated project/home .env files overriding API settings.
+dotenv.config({ path: GLOBAL_ENV_FILE });
 const __dirname = path.dirname(fileURLToPath(import.meta.url));
 // In dist/index.js, package.json is usually up one level in the root
 const pkgPath = path.join(__dirname, '..', 'package.json');
@@ -406,6 +409,32 @@ async function runChat(queryParts, options) {
                 console.log(chalk.cyan("Goodbye!"));
                 break;
             }
+            if (userInput.toLowerCase() === '/view') {
+                if (agent.lastOutputFile && fs.existsSync(agent.lastOutputFile)) {
+                    rl.pause();
+                    try {
+                        await new Promise((resolve, reject) => {
+                            const isWin = process.platform === 'win32';
+                            const cmd = isWin ? 'more' : (process.env.PAGER || 'less');
+                            const args = isWin ? [agent.lastOutputFile] : ['-R', agent.lastOutputFile];
+                            const child = spawn(cmd, args, { stdio: 'inherit' });
+                            child.on('close', () => resolve());
+                            child.on('error', (err) => {
+                                console.error(chalk.red(`Failed to open pager: ${err.message}`));
+                                console.log(chalk.dim(`You can manually view: ${agent.lastOutputFile}`));
+                                resolve();
+                            });
+                        });
+                    }
+                    finally {
+                        rl.resume();
+                    }
+                }
+                else {
+                    console.log(chalk.yellow("No tool output to view."));
+                }
+                continue;
+            }
             if (userInput.trim() === '')
                 continue;
             rl.pause();
@@ -418,7 +447,7 @@ async function runChat(queryParts, options) {
         }
     }
     catch (err) {
-        if (err.message && (err.message.includes('User force closed') || err.message.includes('Prompt was canceled'))) {
+        if (isUserAbort(err)) {
             console.log(chalk.cyan("\nGoodbye!"));
         }
         else {
@@ -429,9 +458,13 @@ async function runChat(queryParts, options) {
         rl.close();
     }
 }
+function isUserAbort(err) {
+    return err.code === 'ABORT_ERR'
+        || (err.message && (err.message.includes('User force closed') || err.message.includes('Prompt was canceled')));
+}
 // Global error handler
 main().catch(err => {
-    if (err.message && (err.message.includes('User force closed') || err.message.includes('Prompt was canceled'))) {
+    if (isUserAbort(err)) {
         console.log(chalk.cyan("\nGoodbye!"));
         process.exit(0);
     }

package/dist/tools/search.js

@@ -49,22 +49,22 @@ export const SearchTool = {
             }
             const data = await response.json();
             // Format the results beautifully for the LLM
-            let output = `Search Results for "${args.query}":
-
+            let output = `Search Results for "${args.query}":
+
 `;
             if (data.answer) {
-                output += `💡 **Direct Answer**: ${data.answer}
-
+                output += `💡 **Direct Answer**: ${data.answer}
+
 `;
             }
             if (data.results && Array.isArray(data.results)) {
                 data.results.forEach((result, index) => {
-                    output += `### ${index + 1}. ${result.title}
+                    output += `### ${index + 1}. ${result.title}
 `;
-                    output += `🔗 ${result.url}
+                    output += `🔗 ${result.url}
 `;
-                    output += `📝 ${result.content}
-
+                    output += `📝 ${result.content}
+
 `;
                 });
             }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "autoclaw",
-  "version": "1.0.39",
+  "version": "1.1.0",
   "type": "module",
   "main": "dist/index.js",
   "bin": {

package/dist/tools.js

@@ -1,130 +0,0 @@
-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}`;
-    }
-}