#第 03 章:补齐四大工具 read/write/edit

/** pi 的默认截断上限:2000 行 / 50KB,谁先到谁生效 */
const MAX_LINES = 2000;
const MAX_BYTES = 50 * 1024;

function truncateHead(content: string): string {
  const lines = content.split("\n");
  let out = lines.slice(0, MAX_LINES).join("\n");
  let truncatedBy: "lines" | "bytes" | null = lines.length > MAX_LINES ? "lines" : null;
  if (Buffer.byteLength(out) > MAX_BYTES) {
    out = Buffer.from(out).subarray(0, MAX_BYTES).toString("utf8");
    out = out.slice(0, out.lastIndexOf("\n")); // 不返回半行
    truncatedBy = "bytes";
  }
  if (!truncatedBy) return content;
  return `${out}\n\n[Output truncated by ${truncatedBy}: total ${lines.length} lines / ${Buffer.byteLength(content)} bytes. Use offset/limit or more specific commands to read more.]`;
}

import { mkdir, readFile, writeFile } from "node:fs/promises";
import { dirname, resolve } from "node:path";

async function toolRead(args: { path: string; offset?: number; limit?: number }): Promise<string> {
  const p = resolve(process.cwd(), args.path);
  const text = await readFile(p, "utf8");
  const lines = text.split("\n");
  const start = Math.max(0, (args.offset ?? 1) - 1);
  const sliced = lines.slice(start, args.limit !== undefined ? start + args.limit : undefined);
  return truncateHead(sliced.join("\n"));
}

async function toolWrite(args: { path: string; content: string }): Promise<string> {
  const p = resolve(process.cwd(), args.path);
  await mkdir(dirname(p), { recursive: true });
  await writeFile(p, args.content, "utf8");
  return `Wrote ${Buffer.byteLength(args.content)} bytes to ${args.path}`;
}

async function toolEdit(args: { path: string; oldText: string; newText: string }): Promise<string> {
  const p = resolve(process.cwd(), args.path);
  const text = await readFile(p, "utf8");
  const count = text.split(args.oldText).length - 1;
  if (count === 0) throw new Error(`oldText not found in ${args.path}. Read the file first to get exact content.`);
  if (count > 1)
    throw new Error(`oldText matches ${count} locations in ${args.path}. Provide more context to make it unique.`);
  await writeFile(p, text.replace(args.oldText, args.newText), "utf8");
  return `Edited ${args.path}: replaced ${args.oldText.length} chars with ${args.newText.length} chars`;
}

{
  type: "function",
  function: {
    name: "read",
    description:
      "Read the contents of a file. For text files, defaults to first 2000 lines. Use offset/limit for large files.",
    parameters: {
      type: "object",
      properties: {
        path: { type: "string", description: "Path to the file to read (relative or absolute)" },
        offset: { type: "number", description: "Line number to start reading from (1-indexed)" },
        limit: { type: "number", description: "Maximum number of lines to read" },
      },
      required: ["path"],
    },
  },
},
{
  type: "function",
  function: {
    name: "edit",
    description:
      "Edit a file by replacing exact text. The oldText must match exactly (including whitespace). Use this for precise, surgical edits.",
    parameters: {
      type: "object",
      properties: {
        path: { type: "string", description: "Path to the file to edit (relative or absolute)" },
        oldText: { type: "string", description: "Exact text to find and replace (must match exactly)" },
        newText: { type: "string", description: "New text to replace the old text with" },
      },
      required: ["path", "oldText", "newText"],
    },
  },
},
{
  type: "function",
  function: {
    name: "write",
    description:
      "Write content to a file. Creates the file if it doesn't exist, overwrites if it does. Automatically creates parent directories.",
    parameters: {
      type: "object",
      properties: {
        path: { type: "string", description: "Path to the file to write (relative or absolute)" },
        content: { type: "string", description: "Content to write to the file" },
      },
      required: ["path", "content"],
    },
  },
},

    switch (name) {
      case "read":
        return { content: await toolRead(args), isError: false };
      case "write":
        return { content: await toolWrite(args), isError: false };
      case "edit":
        return { content: await toolEdit(args), isError: false };
      case "bash":
        return { content: await toolBash(args), isError: false };
      default:
        throw new Error(`Unknown tool: ${name}`);
    }