glosc-mcp 1.0.6 → 1.1.0

package/README.md

@@ -29,4 +29,10 @@
 
 - `openRef`
 	- 打开引用（文件/文件夹/URL/可执行文件），使用系统默认方式打开（Windows 下使用 `Start-Process`）
-	- 入参：`{ target: string, args?: string[], wait?: boolean }`
+	- 入参：`{ target: string, args?: string[], wait?: boolean }`
+
+- `editText`
+  - 文本写入/编辑：按行添加/替换/删除（可批量），或创建/替换/删除整个文件
+  - 入参（概要）：
+    - 整文件：`{ path, file: { action: "create"|"replace"|"delete", content?, overwrite? }, encoding?, newline?, ensureFinalNewline?, returnContent? }`
+    - 按行：`{ path, edits: [{ op: "add"|"replace"|"delete", ... }], createIfMissing?, encoding?, newline?, ensureFinalNewline?, returnContent? }`

package/build/GloscMcp.js

@@ -53,23 +53,6 @@ export class GloscMcp {
                 ],
             };
         });
-        this.server.registerTool("web-search", {
-            description: "使用 Bing 联网搜索信息",
-            inputSchema: z.object({
-                query: z.string().describe("搜索查询内容"),
-            }),
-        }, async (input) => {
-            const url = `https://cn.bing.com/search?q=${encodeURIComponent(input.query)}`;
-            const content = await GloscTools.usebrowser(url, true, "text");
-            return {
-                content: [
-                    {
-                        type: "text",
-                        text: content,
-                    },
-                ],
-            };
-        });
         this.server.registerTool("readFile", {
             description: "读取文件内容，支持多种文件类型：文本、图片、表格、文档、压缩包（ZIP、RAR、7Z、TAR、GZ等）",
             inputSchema: z.object({
@@ -195,6 +178,144 @@ export class GloscMcp {
                 ],
             };
         });
+        this.server.registerTool("editText", {
+            description: "文本写入/编辑：支持按行添加/替换/删除（可批量），或创建/替换/删除整个文件",
+            inputSchema: z
+                .object({
+                path: z.string().describe("文件的绝对路径"),
+                encoding: z
+                    .string()
+                    .describe("文本编码（默认 utf8）")
+                    .default("utf8"),
+                newline: z
+                    .enum(["auto", "lf", "crlf"])
+                    .describe("换行符策略：auto/lf/crlf")
+                    .default("auto"),
+                ensureFinalNewline: z
+                    .boolean()
+                    .describe("是否确保文件末尾以换行结尾")
+                    .default(false),
+                returnContent: z
+                    .boolean()
+                    .describe("是否在结果中返回最终内容（可能很大）")
+                    .default(false),
+                createIfMissing: z
+                    .boolean()
+                    .describe("按行 edits 时文件不存在是否自动新建（默认 false）")
+                    .default(false),
+                file: z
+                    .union([
+                    z.object({
+                        action: z
+                            .literal("create")
+                            .describe("新建文件"),
+                        content: z.string().describe("文件内容"),
+                        overwrite: z
+                            .boolean()
+                            .describe("文件已存在时是否覆盖")
+                            .default(false),
+                    }),
+                    z.object({
+                        action: z
+                            .literal("replace")
+                            .describe("替换整个文件内容"),
+                        content: z.string().describe("文件内容"),
+                    }),
+                    z.object({
+                        action: z
+                            .literal("delete")
+                            .describe("删除文件"),
+                    }),
+                ])
+                    .optional(),
+                edits: z
+                    .array(z.union([
+                    z.object({
+                        op: z.literal("add"),
+                        at: z
+                            .number()
+                            .int()
+                            .min(1)
+                            .describe("插入位置行号（1-based）；允许 lineCount+1 表示追加"),
+                        position: z
+                            .enum(["before", "after"])
+                            .describe("插入到该行之前或之后")
+                            .default("before"),
+                        lines: z
+                            .array(z.string())
+                            .min(1)
+                            .describe("要插入的行（不含换行符）"),
+                    }),
+                    z.object({
+                        op: z.literal("replace"),
+                        start: z
+                            .number()
+                            .int()
+                            .min(1)
+                            .describe("起始行号（1-based）"),
+                        end: z
+                            .number()
+                            .int()
+                            .min(1)
+                            .optional()
+                            .describe("结束行号（1-based，含）；缺省则等于 start"),
+                        lines: z
+                            .array(z.string())
+                            .describe("替换后的行（可多行）"),
+                    }),
+                    z.object({
+                        op: z.literal("delete"),
+                        start: z
+                            .number()
+                            .int()
+                            .min(1)
+                            .describe("起始行号（1-based）"),
+                        end: z
+                            .number()
+                            .int()
+                            .min(1)
+                            .optional()
+                            .describe("结束行号（1-based，含）；缺省则等于 start"),
+                    }),
+                ]))
+                    .optional(),
+            })
+                .refine((v) => !!v.file !== !!v.edits, {
+                message: "必须且只能提供 file 或 edits 之一",
+            }),
+        }, async (input) => {
+            try {
+                const res = await GloscTools.editTextFile({
+                    path: input.path,
+                    encoding: input.encoding,
+                    newline: input.newline,
+                    ensureFinalNewline: input.ensureFinalNewline,
+                    returnContent: input.returnContent,
+                    createIfMissing: input.createIfMissing,
+                    file: input.file,
+                    edits: input.edits,
+                });
+                return {
+                    content: [
+                        {
+                            type: "text",
+                            text: JSON.stringify(res, null, 2),
+                        },
+                    ],
+                };
+            }
+            catch (error) {
+                const errorMessage = error instanceof Error ? error.message : String(error);
+                return {
+                    content: [
+                        {
+                            type: "text",
+                            text: `编辑文本失败: ${errorMessage}`,
+                        },
+                    ],
+                };
+            }
+        });
     }
     /**
      * 注册资源

package/build/GloscTools.js

@@ -492,4 +492,200 @@ if ($null -ne $apps) {
             }
         }
     }
+    static normalizeNewlineOption(newline, existingContent) {
+        if (newline === "crlf")
+            return "\r\n";
+        if (newline === "lf")
+            return "\n";
+        // auto
+        if (typeof existingContent === "string" &&
+            existingContent.includes("\r\n")) {
+            return "\r\n";
+        }
+        return "\n";
+    }
+    static splitLinesPreserveEmptyEnd(text) {
+        // 支持 \n / \r\n，且保留末尾空行（比如文件以换行结尾）
+        if (text === "")
+            return [""];
+        const lines = text.split(/\r?\n/);
+        return lines;
+    }
+    static joinLines(lines, newline) {
+        return lines.join(newline);
+    }
+    static async editTextFile(options) {
+        const filePath = options.path?.trim();
+        if (!filePath)
+            throw new Error("path 不能为空");
+        const encoding = options.encoding ?? "utf8";
+        const returnContent = options.returnContent ?? false;
+        const createIfMissing = options.createIfMissing ?? false;
+        const hasFileAction = !!options.file;
+        const hasEdits = Array.isArray(options.edits) && options.edits.length > 0;
+        if ((hasFileAction && hasEdits) || (!hasFileAction && !hasEdits)) {
+            throw new Error("必须且只能提供 file 或 edits 之一");
+        }
+        let existedBefore = true;
+        let originalBuffer = null;
+        try {
+            originalBuffer = await fs.readFile(filePath);
+        }
+        catch (e) {
+            if (e && (e.code === "ENOENT" || e.code === "ENOTDIR")) {
+                existedBefore = false;
+                originalBuffer = null;
+            }
+            else {
+                throw e;
+            }
+        }
+        if (options.file) {
+            const action = options.file.action;
+            if (action === "delete") {
+                if (existedBefore) {
+                    await fs.unlink(filePath);
+                }
+                return {
+                    ok: true,
+                    path: filePath,
+                    action: "delete",
+                    existedBefore,
+                };
+            }
+            if (action === "create") {
+                if (existedBefore && !options.file.overwrite) {
+                    throw new Error("文件已存在，action=create 且 overwrite=false");
+                }
+                await fs.mkdir(path.dirname(filePath), { recursive: true });
+                const newline = GloscTools.normalizeNewlineOption(options.newline, undefined);
+                let content = options.file.content ?? "";
+                if (options.ensureFinalNewline) {
+                    if (!content.endsWith("\n") && !content.endsWith("\r\n")) {
+                        content += newline;
+                    }
+                }
+                const outBuffer = iconv.encode(content, encoding);
+                await fs.writeFile(filePath, outBuffer);
+                return {
+                    ok: true,
+                    path: filePath,
+                    action: existedBefore ? "replace" : "create",
+                    existedBefore,
+                    bytesWritten: outBuffer.length,
+                    content: returnContent ? content : undefined,
+                };
+            }
+            // replace
+            await fs.mkdir(path.dirname(filePath), { recursive: true });
+            const decodedExisting = originalBuffer != null
+                ? iconv.decode(originalBuffer, encoding)
+                : undefined;
+            const newline = GloscTools.normalizeNewlineOption(options.newline, decodedExisting);
+            let content = options.file.content ?? "";
+            if (options.ensureFinalNewline) {
+                if (!content.endsWith("\n") && !content.endsWith("\r\n")) {
+                    content += newline;
+                }
+            }
+            const outBuffer = iconv.encode(content, encoding);
+            await fs.writeFile(filePath, outBuffer);
+            return {
+                ok: true,
+                path: filePath,
+                action: "replace",
+                existedBefore,
+                bytesWritten: outBuffer.length,
+                content: returnContent ? content : undefined,
+            };
+        }
+        // line edits
+        let text = "";
+        if (originalBuffer != null) {
+            text = iconv.decode(originalBuffer, encoding);
+        }
+        else {
+            if (!createIfMissing) {
+                throw new Error("文件不存在；如需新建请使用 file.action=create 或 createIfMissing=true");
+            }
+            await fs.mkdir(path.dirname(filePath), { recursive: true });
+            text = "";
+        }
+        const newline = GloscTools.normalizeNewlineOption(options.newline, text);
+        // 注意：split 后如果原文为空，返回 [""]，这样 lineCount 语义更贴近编辑器
+        let lines = GloscTools.splitLinesPreserveEmptyEnd(text);
+        const lineCountBefore = lines.length;
+        const edits = options.edits ?? [];
+        for (const edit of edits) {
+            if (edit.op === "add") {
+                const position = edit.position ?? "before";
+                const at = Math.trunc(edit.at);
+                if (!Number.isFinite(at) || at < 1) {
+                    throw new Error("add.at 必须为 >=1 的整数");
+                }
+                // 允许 at = lines.length + 1（before）用于追加到末尾
+                const maxAt = lines.length + 1;
+                if (at > maxAt) {
+                    throw new Error(`add.at 超出范围：当前最大允许 ${maxAt}（可用 lineCount+1 追加）`);
+                }
+                const insertIndex = position === "after"
+                    ? Math.min(at, lines.length) // after 最多插在最后一行之后
+                    : at - 1;
+                lines.splice(insertIndex, 0, ...edit.lines);
+            }
+            else if (edit.op === "replace") {
+                const start = Math.trunc(edit.start);
+                const end = Math.trunc(edit.end ?? edit.start);
+                if (!Number.isFinite(start) || start < 1) {
+                    throw new Error("replace.start 必须为 >=1 的整数");
+                }
+                if (!Number.isFinite(end) || end < start) {
+                    throw new Error("replace.end 必须为 >= start 的整数");
+                }
+                if (end > lines.length) {
+                    throw new Error(`replace 超出范围：当前行数 ${lines.length}`);
+                }
+                lines.splice(start - 1, end - start + 1, ...edit.lines);
+            }
+            else if (edit.op === "delete") {
+                const start = Math.trunc(edit.start);
+                const end = Math.trunc(edit.end ?? edit.start);
+                if (!Number.isFinite(start) || start < 1) {
+                    throw new Error("delete.start 必须为 >=1 的整数");
+                }
+                if (!Number.isFinite(end) || end < start) {
+                    throw new Error("delete.end 必须为 >= start 的整数");
+                }
+                if (end > lines.length) {
+                    throw new Error(`delete 超出范围：当前行数 ${lines.length}`);
+                }
+                lines.splice(start - 1, end - start + 1);
+                if (lines.length === 0)
+                    lines = [""];
+            }
+            else {
+                const neverEdit = edit;
+                throw new Error(`未知 edit.op: ${neverEdit.op}`);
+            }
+        }
+        let outText = GloscTools.joinLines(lines, newline);
+        if (options.ensureFinalNewline) {
+            if (!outText.endsWith("\n") && !outText.endsWith("\r\n")) {
+                outText += newline;
+            }
+        }
+        const outBuffer = iconv.encode(outText, encoding);
+        await fs.writeFile(filePath, outBuffer);
+        return {
+            ok: true,
+            path: filePath,
+            action: "edit",
+            existedBefore,
+            lineCountBefore,
+            lineCountAfter: lines.length,
+            editsApplied: edits.length,
+            bytesWritten: outBuffer.length,
+            content: returnContent ? outText : undefined,
+        };
+    }
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "glosc-mcp",
-  "version": "1.0.6",
+  "version": "1.1.0",
   "main": "index.js",
   "type": "module",
   "bin": {