动手写一个
终端 Agent

import { readFile, writeFile, realpath, lstat } from "node:fs/promises";
import path from "node:path";
import readline from "node:readline/promises";

const KEY = process.env.OPENAI_API_KEY;
const URL = process.env.OPENAI_BASE_URL || "https://api.openai.com/v1";
const MODEL = process.env.OPENAI_MODEL || "gpt-4o-mini";
const ROOT = process.cwd();
let rootRealPath;

const tools = [
  {
    type: "function",
    function: {
      name: "read_file",
      description: "读取当前项目目录中的 UTF-8 文本文件",
      parameters: {
        type: "object",
        properties: {
          path: { type: "string", description: "相对当前项目目录的文件路径" },
        },
        required: ["path"],
      },
    },
  },
  {
    type: "function",
    function: {
      name: "write_file",
      description: "把完整文本写入当前项目目录中的文件",
      parameters: {
        type: "object",
        properties: {
          path: { type: "string", description: "相对当前项目目录的文件路径" },
          content: { type: "string", description: "要写入的完整文件内容" },
        },
        required: ["path", "content"],
      },
    },
  },
];

function checkRelativePath(filePath) {
  if (path.isAbsolute(filePath)) throw new Error("只允许相对路径");
  const fullPath = path.resolve(ROOT, filePath);
  const relative = path.relative(ROOT, fullPath);
  if (relative.startsWith("..") || path.isAbsolute(relative)) {
    throw new Error("不能访问项目目录之外的文件");
  }
  return fullPath;
}

function checkInsideRoot(realTarget, root) {
  const relative = path.relative(root, realTarget);
  if (relative.startsWith("..") || path.isAbsolute(relative)) {
    throw new Error("不能访问项目目录之外的文件");
  }
}

async function getRootRealPath() {
  if (!rootRealPath) {
    rootRealPath = await realpath(ROOT);
  }
  return rootRealPath;
}

async function safePath(filePath, forWrite = false) {
  const fullPath = checkRelativePath(filePath);
  const root = await getRootRealPath();

  if (forWrite) {
    try {
      const stat = await lstat(fullPath);
      if (stat.isSymbolicLink()) {
        throw new Error("不能通过符号链接写入文件");
      }
    } catch (error) {
      if (error.code !== "ENOENT") throw error;
    }
    const realParent = await realpath(path.dirname(fullPath));
    checkInsideRoot(realParent, root);
    return fullPath;
  }

  const realTarget = await realpath(fullPath);
  checkInsideRoot(realTarget, root);
  return realTarget;
}

async function runTool(name, args) {
  if (name === "read_file") {
    return readFile(await safePath(args.path), "utf8");
  }
  if (name === "write_file") {
    await writeFile(await safePath(args.path, true), args.content, "utf8");
    return `已写入 ${args.path}`;
  }
  throw new Error(`未知工具：${name}`);
}

async function ask(messages) {
  const res = await fetch(`${URL}/chat/completions`, {
    method: "POST",
    headers: {
      "Content-Type": "application/json",
      Authorization: `Bearer ${KEY}`,
    },
    body: JSON.stringify({ model: MODEL, messages, tools }),
  });
  if (!res.ok) throw new Error(`API ${res.status}: ${await res.text()}`);
  const data = await res.json();
  return data.choices[0].message;
}

async function runAgent(messages) {
  for (let round = 0; round < 6; round += 1) {
    const reply = await ask(messages);
    messages.push(reply);
    if (!reply.tool_calls?.length) return reply.content || "任务完成";

    for (const call of reply.tool_calls) {
      let result;
      try {
        const args = JSON.parse(call.function.arguments);
        result = await runTool(call.function.name, args);
      } catch (error) {
        result = `工具执行失败：${error.message}`;
      }
      messages.push({
        role: "tool",
        tool_call_id: call.id,
        content: result,
      });
    }
  }
  return "工具调用次数过多，请把任务说得更具体。";
}

const rl = readline.createInterface({
  input: process.stdin,
  output: process.stdout,
});
const messages = [{
  role: "system",
  content: "你是文件助手。写入前先读取原文件，不要删除原有内容。",
}];

console.log("开始聊天，输入 exit 退出");
while (true) {
  const q = (await rl.question("你: ")).trim();
  if (!q || q === "exit") break;
  messages.push({ role: "user", content: q });
  try {
    console.log("AI:", await runAgent(messages));
  } catch (error) {
    console.error("错误:", error.message);
  }
}
rl.close();