ningzhi-agent-cli 0.0.1

package/dist/agent/skills.js

@@ -0,0 +1,103 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.discoverSkills = discoverSkills;
+exports.loadSkill = loadSkill;
+exports.getSkillsListText = getSkillsListText;
+const fs_1 = require("fs");
+const node_path_1 = require("node:path");
+const node_os_1 = require("node:os");
+const skills = [];
+const skillContentMap = new Map();
+// 解析 SKILL.md 文件顶部的 frontmatter(用 --- 包裹的 YAML 头)
+// 提取其中的 name 和 description 字段,供技能注册使用
+function parseFrontmatter(content) {
+    // 校验:必须以 "---" 开头,否则不是合法的 frontmatter
+    if (!content.startsWith("---")) {
+        return { name: "", description: "" };
+    }
+    // 查找闭合的 "---"(从索引 3 开始,跳过开头那一个)
+    const endIdx = content.indexOf("---", 3);
+    if (endIdx === -1) {
+        return { name: "", description: "" };
+    }
+    // 截取两个 "---" 之间的内容,按行解析为 key-value 键值对
+    const frontmatter = content.slice(3, endIdx).trim();
+    const lines = frontmatter.split("\n");
+    const result = {};
+    for (const line of lines) {
+        // 每行格式为 "key: value",没有冒号的行直接跳过
+        const colonIdx = line.indexOf(":");
+        if (colonIdx === -1)
+            continue;
+        const key = line.slice(0, colonIdx).trim();
+        const value = line.slice(colonIdx + 1).trim();
+        result[key] = value;
+    }
+    // 返回 name 和 description,缺失时回退为空字符串
+    return { name: result.name || "", description: result.description || "" };
+}
+// 发现所有技能目录下的 SKILL.md 文件
+function discoverSkills() {
+    // 重置缓存:清空技能列表和内容映射,避免重复累积
+    skills.length = 0;
+    skillContentMap.clear();
+    const skillDirs = [
+        (0, node_path_1.join)((0, node_os_1.homedir)(), ".agents", "skills"), // 全局skill
+        (0, node_path_1.join)((0, node_os_1.homedir)(), ".ningzhiAgentCli", ".agents", "skills"), // 工作空间，第三方安装的skill
+        (0, node_path_1.join)((0, node_os_1.homedir)(), ".ningzhiAgentCli", "skills"), // 工作空间，用户自己创建的
+        (0, node_path_1.join)(__dirname, "skills"), // cli 内置的 skill
+    ];
+    for (const skillsDir of skillDirs) {
+        let entries;
+        try {
+            entries = (0, fs_1.readdirSync)(skillsDir); // 读取目录下的所有文件和子目录
+        }
+        catch {
+            continue;
+        }
+        for (const entry of entries) {
+            const entryPath = (0, node_path_1.join)(skillsDir, entry); // entryPath 是当前目录下的文件或子目录路径,包含 skillsDir
+            try {
+                const entryStat = (0, fs_1.statSync)(entryPath); // 获取文件或目录的元信息
+                if (!entryStat.isDirectory())
+                    continue;
+                const skillMdPath = (0, node_path_1.join)(entryPath, "SKILL.md");
+                const content = (0, fs_1.readFileSync)(skillMdPath, "utf-8");
+                const { name, description } = parseFrontmatter(content);
+                if (name && description) {
+                    const existing = skills.find((s) => s.name === name);
+                    if (existing) {
+                        existing.description = description;
+                        existing.dirPath = entryPath;
+                    }
+                    else {
+                        skills.push({ name, description, dirPath: entryPath });
+                    }
+                    skillContentMap.set(name, content);
+                }
+            }
+            catch {
+                // 忽略没有 SKILL.md 的目录或解析失败的情况
+            }
+        }
+    }
+    return skills;
+}
+// 根据技能名称从缓存中加载完整的 SKILL.md 内容
+function loadSkill(name) {
+    return skillContentMap.get(name) ?? null;
+}
+// 生成技能列表的 Markdown 文本,用于展示给用户或 LLM
+function getSkillsListText() {
+    // 将每个技能格式化为 Markdown 无序列表项: "- **技能名**: 描述"
+    const lines = skills.map((s) => `- **${s.name}**: ${s.description}`);
+    if (skills.length > 0) {
+        lines.push("");
+        lines.push("skills 的目录:");
+        lines.push((0, node_path_1.join)((0, node_os_1.homedir)(), ".agents", "skills"));
+        lines.push((0, node_path_1.join)((0, node_os_1.homedir)(), ".ningzhiAgentCli", ".agents", "skills"));
+        lines.push((0, node_path_1.join)((0, node_os_1.homedir)(), ".ningzhiAgentCli", "skills"));
+        lines.push(`如果增加新 skill，必须放在 ${(0, node_path_1.join)((0, node_os_1.homedir)(), ".ningzhiAgentCli", "skills")} 目录下`);
+    }
+    return lines.join("\n");
+}

package/dist/agent/tools/agent_tool.d.ts

@@ -0,0 +1,3 @@
+export declare function agentTool({ prompt, }: {
+    prompt: string;
+}): Promise<string>;

package/dist/agent/tools/agent_tool.js

@@ -0,0 +1,44 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.agentTool = agentTool;
+async function agentTool({ prompt, }) {
+    if (!prompt || !prompt.trim()) {
+        return "Error: prompt is empty.";
+    }
+    // 动态 import 避免循环依赖：agent.ts -> tools.ts -> agent_tool.ts -> agent.ts
+    const { runSubAgent } = await Promise.resolve().then(() => __importStar(require("../agent")));
+    return runSubAgent(prompt.trim());
+}

package/dist/agent/tools/exec_tool.d.ts

@@ -0,0 +1,3 @@
+export declare function execTool({ command, }: {
+    command: string;
+}): Promise<string>;

package/dist/agent/tools/exec_tool.js

@@ -0,0 +1,33 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.execTool = execTool;
+const node_child_process_1 = require("node:child_process");
+const node_util_1 = require("node:util");
+const execAsync = (0, node_util_1.promisify)(node_child_process_1.exec);
+async function execTool({ command, }) {
+    const trimmed = command.trim();
+    if (!trimmed) {
+        return "Error: command is empty.";
+    }
+    if (trimmed.includes("..")) {
+        return "Error: parent directory references (..) are not allowed.";
+    }
+    const spaceIdx = trimmed.indexOf(" ");
+    const args = spaceIdx > 0 ? trimmed.slice(spaceIdx) : "";
+    // 在命令参数中查找 Unix 风格的绝对路径（以 / 开头），禁止使用绝对路径以限制文件访问范围
+    // (?:^|\s) 匹配行首或空白符位置，(\/[^ ]+) 捕获以 / 开头、不含空格的路径
+    const absolutePathMatch = args.match(/(?:^|\s)(\/[^ ]+)/);
+    if (absolutePathMatch) {
+        return `Error: absolute paths are not allowed: "${absolutePathMatch[1]}"`;
+    }
+    try {
+        const { stdout, stderr } = await execAsync(trimmed, {
+            cwd: process.cwd(),
+            timeout: 30000,
+        });
+        return stdout || stderr || "Command executed successfully with no output.";
+    }
+    catch (err) {
+        return `Error: ${err.message}`;
+    }
+}

package/dist/agent/tools/load_skill_tool.d.ts

@@ -0,0 +1,3 @@
+export declare function loadSkillTool({ name, }: {
+    name: string;
+}): Promise<string>;

package/dist/agent/tools/load_skill_tool.js

@@ -0,0 +1,16 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.loadSkillTool = loadSkillTool;
+const skills_1 = require("../skills");
+// 根据 skill 名称 返回整个 SKILL.md 文件内容
+async function loadSkillTool({ name, }) {
+    const trimmed = name.trim();
+    if (!trimmed) {
+        return "Error: skill name is empty.";
+    }
+    const content = (0, skills_1.loadSkill)(trimmed);
+    if (!content) {
+        return `Error: skill "${trimmed}" not found.`;
+    }
+    return content;
+}

package/dist/agent/tools/memory_create_tool.d.ts

@@ -0,0 +1,6 @@
+export declare function memoryCreateTool({ type, content, keywords, importance, }: {
+    type: string;
+    content: string;
+    keywords?: string[];
+    importance?: number;
+}, config?: any): Promise<string>;

package/dist/agent/tools/memory_create_tool.js

@@ -0,0 +1,39 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.memoryCreateTool = memoryCreateTool;
+const better_sqlite3_1 = __importDefault(require("better-sqlite3"));
+const db_1 = require("../db");
+const VALID_TYPES = ["fact", "event", "preference", "skill"];
+async function memoryCreateTool({ type, content, keywords, importance, }, config) {
+    if (!VALID_TYPES.includes(type)) {
+        return `Error: type must be one of ${VALID_TYPES.join(", ")}.`;
+    }
+    const trimmed = content?.trim();
+    if (!trimmed) {
+        return "Error: content is required.";
+    }
+    const importanceValue = importance ?? 3;
+    if (importanceValue < 1 || importanceValue > 5) {
+        return "Error: importance must be between 1 and 5.";
+    }
+    const sessionId = config?.configurable?.thread_id ?? "default-session";
+    const keywordsJson = keywords && keywords.length > 0 ? JSON.stringify(keywords) : null;
+    const db = new better_sqlite3_1.default(db_1.DB_PATH);
+    try {
+        // stmt指的是预处理语句（prepared statement）。预处理语句是一种数据库功能，允许开发者编写一次SQL语句，然后多次执行，只需传递不同的参数。
+        // 这种方法提高了性能，因为SQL语句只解析一次，而不是每次执行时都解析，同时也减少了网络通信量
+        const stmt = db.prepare(`INSERT INTO memory (type, content, keywords, importance, session_id)
+       VALUES (?, ?, ?, ?, ?)`);
+        stmt.run(type, trimmed, keywordsJson, importanceValue, sessionId);
+        return "Memory saved successfully.";
+    }
+    catch (err) {
+        return `Error: ${err.message}`;
+    }
+    finally {
+        db.close();
+    }
+}

package/dist/agent/tools/memory_delete_tool.d.ts

@@ -0,0 +1,3 @@
+export declare function memoryDeleteTool({ id, }: {
+    id: number;
+}, _config?: any): Promise<string>;

package/dist/agent/tools/memory_delete_tool.js

@@ -0,0 +1,28 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.memoryDeleteTool = memoryDeleteTool;
+const better_sqlite3_1 = __importDefault(require("better-sqlite3"));
+const db_1 = require("../db");
+async function memoryDeleteTool({ id, }, _config) {
+    if (!Number.isFinite(id) || id <= 0) {
+        return "Error: id must be a positive integer.";
+    }
+    const db = new better_sqlite3_1.default(db_1.DB_PATH);
+    try {
+        const existing = db.prepare("SELECT 1 FROM memory WHERE id = ?").get(id);
+        if (!existing) {
+            return `Error: no memory found with id ${id}.`;
+        }
+        db.prepare("DELETE FROM memory WHERE id = ?").run(id);
+        return `Memory ${id} deleted successfully.`;
+    }
+    catch (err) {
+        return `Error: ${err.message}`;
+    }
+    finally {
+        db.close();
+    }
+}

package/dist/agent/tools/memory_retrieve_tool.d.ts

@@ -0,0 +1,4 @@
+export declare function memoryRetrieveTool({ query, limit, }: {
+    query: string[];
+    limit?: number;
+}, config?: any): Promise<string>;

package/dist/agent/tools/memory_retrieve_tool.js

@@ -0,0 +1,26 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.memoryRetrieveTool = memoryRetrieveTool;
+const db_1 = require("../db");
+async function memoryRetrieveTool({ query, limit, }, config) {
+    const trimmedQueries = query
+        ?.map((q) => q.trim())
+        .filter((q) => q.length > 0);
+    if (!trimmedQueries || trimmedQueries.length === 0) {
+        return "Error: query is required.";
+    }
+    const limitValue = limit ?? 10;
+    if (limitValue < 1 || limitValue > 50) {
+        return "Error: limit must be between 1 and 50.";
+    }
+    try {
+        const results = (0, db_1.searchMemories)(trimmedQueries, limitValue);
+        if (results.length === 0) {
+            return "No relevant memories found.";
+        }
+        return JSON.stringify(results);
+    }
+    catch (err) {
+        return `Error: ${err.message}`;
+    }
+}

package/dist/agent/tools/profile_update_tool.d.ts

@@ -0,0 +1,3 @@
+export declare function profileUpdateTool({ profile_info, }: {
+    profile_info: string;
+}): Promise<string>;

package/dist/agent/tools/profile_update_tool.js

@@ -0,0 +1,51 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.profileUpdateTool = profileUpdateTool;
+const promises_1 = require("node:fs/promises");
+const node_path_1 = require("node:path");
+const node_os_1 = require("node:os");
+function getProfilePaths() {
+    const dir = (0, node_path_1.resolve)((0, node_os_1.homedir)(), ".ningzhiAgentCli", ".data");
+    return { dir, path: (0, node_path_1.resolve)(dir, "profile.md") };
+}
+function generateBackupFilename() {
+    const dt = Date.now();
+    const random = Math.random().toString(36).slice(2, 8);
+    return `profile.${dt}-${random}.md`;
+}
+async function profileUpdateTool({ profile_info, }) {
+    if (!profile_info || profile_info.trim().length === 0) {
+        return "Error: profile_info is empty.";
+    }
+    const { dir: profileDir, path: profilePath } = getProfilePaths();
+    try {
+        let existingContent = "";
+        let fileExists = false;
+        try {
+            existingContent = await (0, promises_1.readFile)(profilePath, "utf-8");
+            fileExists = true;
+        }
+        catch (err) {
+            if (err.code !== "ENOENT") {
+                return `Error reading existing profile: ${err.message}`;
+            }
+        }
+        const normalizedNew = profile_info.trim();
+        const normalizedExisting = existingContent.trim();
+        if (fileExists && normalizedNew === normalizedExisting) {
+            return "Profile is already up to date. No changes made.";
+        }
+        await (0, promises_1.mkdir)(profileDir, { recursive: true }); // 幂等 递归创建目录
+        if (fileExists) {
+            const backupFilename = generateBackupFilename();
+            const backupPath = (0, node_path_1.resolve)(profileDir, backupFilename);
+            await (0, promises_1.copyFile)(profilePath, backupPath);
+        }
+        // 更新 profile.md 文件
+        await (0, promises_1.writeFile)(profilePath, profile_info, "utf-8");
+        return `Profile updated successfully. File: ${profilePath}${fileExists ? " (backup created)" : ""}`;
+    }
+    catch (err) {
+        return `Error: ${err.message}`;
+    }
+}

package/dist/agent/tools/read_file_tool.d.ts

@@ -0,0 +1,3 @@
+export declare function readFileTool({ filepath, }: {
+    filepath: string;
+}): Promise<string>;

package/dist/agent/tools/read_file_tool.js

@@ -0,0 +1,16 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.readFileTool = readFileTool;
+const promises_1 = require("node:fs/promises");
+async function readFileTool({ filepath, }) {
+    try {
+        const content = await (0, promises_1.readFile)(filepath, "utf-8");
+        return content;
+    }
+    catch (err) {
+        if (err.code === "ENOENT") {
+            return "Error: file not found.";
+        }
+        return `Error: ${err.message}`;
+    }
+}

package/dist/agent/tools/run_js_tool.d.ts

@@ -0,0 +1,3 @@
+export declare function runJsTool({ code }: {
+    code: string;
+}): Promise<string>;

package/dist/agent/tools/run_js_tool.js

@@ -0,0 +1,47 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.runJsTool = runJsTool;
+const node_child_process_1 = require("node:child_process");
+const node_util_1 = require("node:util");
+const execAsync = (0, node_util_1.promisify)(node_child_process_1.exec);
+async function runJsTool({ code }) {
+    const trimmed = code.trim();
+    if (!trimmed) {
+        return "Error: code is empty.";
+    }
+    try {
+        await execAsync("node --version", { timeout: 5000 });
+    }
+    catch {
+        return "Error: Node.js is not installed on this system. Please install Node.js to execute JavaScript code.";
+    }
+    // 将源码转成 base64 再嵌入命令，避免源码中的引号、换行、$、反引号等字符破坏 shell 命令结构
+    const base64Code = Buffer.from(trimmed).toString("base64");
+    // 用 node -e 执行一段 JS：在子进程里把 base64 解码回原始代码，再 eval 执行
+    const command = `node -e "eval(Buffer.from('${base64Code}', 'base64').toString('utf-8'))"`;
+    try {
+        const { stdout, stderr } = await execAsync(command, {
+            cwd: process.cwd(),
+            timeout: 30000,
+            encoding: "utf8",
+        });
+        // 全面清理子进程输出中的脏字符（兼容 MINGW64/Git Bash、cmd.exe GBK、ANSICON 等多种环境）
+        // 1. 去 ANSI 转义序列（颜色、光标控制等，Git Bash 常见）
+        // 2. 去 BOM、零宽字符、方向控制、替换符等 Unicode 格式字符
+        // 3. 去 ASCII 控制字符（0x00-0x1F），保留换行\n、制表符\t；并把孤立的 \r 回车符删掉
+        // 4. 把连续多个换行折叠成单个（避免 cmd/bash 追加的额外空行）
+        const clean = (s) => s
+            .replace(/\x1B\[[0-9;?]*[A-Za-z]/g, "")
+            .replace(/\uFEFF|[\u200B-\u200D\u200E\u200F\uFFFD]/g, "")
+            .replace(/[\x00-\x08\x0B\x0C\x0E-\x1F\x7F]|\r/g, "")
+            .replace(/\n{2,}/g, "\n");
+        const cleanedStdout = clean(stdout || "").trim();
+        const cleanedStderr = clean(stderr || "").trim();
+        return (cleanedStdout ||
+            cleanedStderr ||
+            "Code executed successfully with no output.");
+    }
+    catch (err) {
+        return `Error: ${err.message}`;
+    }
+}

package/dist/agent/tools/run_py_tool.d.ts

@@ -0,0 +1,3 @@
+export declare function runPyTool({ code }: {
+    code: string;
+}): Promise<string>;

package/dist/agent/tools/run_py_tool.js

@@ -0,0 +1,37 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.runPyTool = runPyTool;
+const node_child_process_1 = require("node:child_process");
+const node_util_1 = require("node:util");
+// 将 exec 转为 Promise 形式,便于用 await 调用
+const execAsync = (0, node_util_1.promisify)(node_child_process_1.exec);
+async function runPyTool({ code }) {
+    // 去除首尾空白,若代码为空直接返回错误
+    const trimmed = code.trim();
+    if (!trimmed) {
+        return "Error: code is empty.";
+    }
+    // 提前检测 python3 是否可用,避免后续执行时报错难以定位
+    try {
+        await execAsync("python3 --version", { timeout: 5000 });
+    }
+    catch {
+        return "Error: Python3 is not installed on this system. Please install Python3 to execute Python code.";
+    }
+    // 将代码转成 base64,再在 Python 端解码执行
+    // 这样做是为了绕过 shell 对引号、换行、特殊字符的转义问题
+    const base64Code = Buffer.from(trimmed).toString("base64");
+    const command = `python3 -c "import base64; exec(base64.b64decode('${base64Code}').decode('utf-8'))"`;
+    try {
+        // 执行 Python 命令,设置工作目录和超时时间
+        const { stdout, stderr } = await execAsync(command, {
+            cwd: process.cwd(), // 以当前进程目录为 Python 执行目录,保证相对路径一致
+            timeout: 30000, // 30 秒超时,防止死循环或长时间阻塞
+        });
+        // 优先返回 stdout,其次 stderr,都没有则返回成功提示
+        return stdout || stderr || "Code executed successfully with no output.";
+    }
+    catch (err) {
+        return `Error: ${err.message}`;
+    }
+}

package/dist/agent/tools/web_fetch_tool.d.ts

@@ -0,0 +1,3 @@
+export declare function webFetchTool({ url }: {
+    url: string;
+}): Promise<string>;

package/dist/agent/tools/web_fetch_tool.js

@@ -0,0 +1,28 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.webFetchTool = webFetchTool;
+const MAX_LENGTH = 8000;
+async function webFetchTool({ url }) {
+    const trimmed = url.trim();
+    if (!trimmed) {
+        return "Error: url is empty.";
+    }
+    try {
+        const response = await fetch(trimmed, {
+            headers: {
+                "User-Agent": "Mozilla/5.0 (compatible; NingzhiBot/1.0)", // 模拟浏览器请求
+            },
+        });
+        if (!response.ok) {
+            return `Error: HTTP ${response.status} ${response.statusText}`;
+        }
+        const text = await response.text();
+        if (text.length > MAX_LENGTH) {
+            return (text.slice(0, MAX_LENGTH) + "\n\n[Content truncated due to length]");
+        }
+        return text;
+    }
+    catch (err) {
+        return `Error: ${err.message}`;
+    }
+}

package/dist/agent/tools/web_search_tool.d.ts

@@ -0,0 +1,3 @@
+export declare function webSearchTool({ query, }: {
+    query: string;
+}): Promise<string>;

package/dist/agent/tools/web_search_tool.js

@@ -0,0 +1,38 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.webSearchTool = webSearchTool;
+const tavily_1 = require("@langchain/tavily");
+const config_1 = require("../config");
+async function webSearchTool({ query, }) {
+    const tavilyApiKey = (0, config_1.getEnv)("TAVILY_API_KEY");
+    if (!tavilyApiKey) {
+        return "Error: 未配置 TAVILY_API_KEY。请在 ~/.ningzhiAgentCli/ningzhi.json 的 env 中设置 TAVILY_API_KEY。";
+    }
+    const tavilySearch = new tavily_1.TavilySearch({
+        maxResults: 2,
+        topic: "general",
+        tavilyApiKey,
+    });
+    try {
+        const result = await tavilySearch.invoke({ query });
+        if ("error" in result && result.error) {
+            return `Error: ${result.error}`;
+        }
+        const lines = [];
+        lines.push(`Query: ${result.query}`);
+        if (result.answer) {
+            lines.push(`Answer: ${result.answer}`);
+        }
+        lines.push("");
+        lines.push("Results:");
+        for (let i = 0; i < result.results.length; i++) {
+            const r = result.results[i];
+            lines.push(`${i + 1}. ${r.title} (${r.url})`);
+            lines.push(`   ${r.content}`);
+        }
+        return lines.join("\n");
+    }
+    catch (err) {
+        return `Error: ${err.message}`;
+    }
+}

package/dist/agent/tools/write_file_tool.d.ts

@@ -0,0 +1,4 @@
+export declare function writeFileTool({ filepath, content, }: {
+    filepath: string;
+    content: string;
+}): Promise<string>;

package/dist/agent/tools/write_file_tool.js

@@ -0,0 +1,15 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.writeFileTool = writeFileTool;
+const promises_1 = require("node:fs/promises");
+const node_path_1 = require("node:path");
+async function writeFileTool({ filepath, content, }) {
+    try {
+        await (0, promises_1.mkdir)((0, node_path_1.dirname)(filepath), { recursive: true }); // recursive 表示创建父目录, 如果没有的话, 则创建
+        await (0, promises_1.writeFile)(filepath, content, "utf-8");
+        return `File "${filepath}" written successfully.`;
+    }
+    catch (err) {
+        return `Error: ${err.message}`;
+    }
+}

package/dist/agent/tools.d.ts

@@ -0,0 +1,14 @@
+import { DynamicStructuredTool } from "@langchain/core/tools";
+export type NingzhiTool = DynamicStructuredTool & {
+    permission_level: string;
+};
+/**
+ * 可能持久化输出，如果输出长度超过最大限制则保存到文件
+ * @param {string} content - 要持久化的输出内容
+ * @param {string} toolCallId - 工具调用 ID，用于生成文件名
+ * @returns {Promise<string>} - 包含持久化信息的 HTML 片段
+ */
+export declare function maybePersistedOutput(content: string, toolCallId: string): Promise<string>;
+export declare const nativeTools: NingzhiTool[];
+export declare let tools: NingzhiTool[];
+export declare function initTools(): Promise<void>;