@myassis/gateway 1.0.0

package/dist/services/task/PushTokenStore.js

@@ -0,0 +1,124 @@
+/**
+ * PushTokenStore - 用户设备推送 Token 存储
+ * 使用 SQLite 管理用户的多设备推送 Token
+ */
+import { getLogger } from '@pocketclaw/shared';
+const logger = getLogger('PushTokenStore');
+import { sessionStore } from '../session/SessionStore';
+export class PushTokenStore {
+    db;
+    constructor() {
+        this.db = sessionStore.getDb();
+        this.initTable();
+    }
+    initTable() {
+        this.db.exec(`
+      CREATE TABLE IF NOT EXISTS push_tokens (
+        id INTEGER PRIMARY KEY AUTOINCREMENT,
+        user_id TEXT NOT NULL,
+        token TEXT NOT NULL,
+        provider TEXT NOT NULL DEFAULT 'expo',
+        device_id TEXT,
+        device_name TEXT,
+        created_at INTEGER NOT NULL,
+        updated_at INTEGER NOT NULL,
+        UNIQUE(user_id, token)
+      )
+    `);
+        // 确保 device_id 和 device_name 列存在（向后兼容）
+        this.ensureColumns();
+        logger.info('Tables initialized');
+    }
+    ensureColumns() {
+        const tableInfo = this.db.prepare("PRAGMA table_info(push_tokens)").all();
+        const columnNames = tableInfo.map((col) => col.name);
+        if (!columnNames.includes('device_id')) {
+            this.db.exec("ALTER TABLE push_tokens ADD COLUMN device_id TEXT");
+            logger.info('Added column: device_id');
+        }
+        if (!columnNames.includes('device_name')) {
+            this.db.exec("ALTER TABLE push_tokens ADD COLUMN device_name TEXT");
+            logger.info('Added column: device_name');
+        }
+        if (!columnNames.includes('provider')) {
+            this.db.exec("ALTER TABLE push_tokens ADD COLUMN provider TEXT DEFAULT 'expo'");
+            logger.info('Added column: provider');
+        }
+    }
+    /**
+     * 添加或更新 Push Token
+     */
+    upsert(tokenData) {
+        const now = Date.now();
+        // 先尝试更新
+        const existing = this.db.prepare('SELECT id FROM push_tokens WHERE user_id = ? AND token = ?').get(tokenData.userId, tokenData.token);
+        if (existing) {
+            this.db.prepare(`
+        UPDATE push_tokens 
+        SET provider = ?, device_id = ?, device_name = ?, updated_at = ?
+        WHERE user_id = ? AND token = ?
+      `).run(tokenData.provider || 'expo', tokenData.deviceId || null, tokenData.deviceName || null, now, tokenData.userId, tokenData.token);
+        }
+        else {
+            this.db.prepare(`
+        INSERT INTO push_tokens (user_id, token, provider, device_id, device_name, created_at, updated_at)
+        VALUES (?, ?, ?, ?, ?, ?, ?)
+      `).run(tokenData.userId, tokenData.token, tokenData.provider || 'expo', tokenData.deviceId || null, tokenData.deviceName || null, now, now);
+        }
+    }
+    /**
+     * 获取用户的所有 Push Token
+     */
+    getByUserId(userId) {
+        const rows = this.db.prepare('SELECT * FROM push_tokens WHERE user_id = ? ORDER BY updated_at DESC').all(userId);
+        return rows.map(row => ({
+            id: row.id,
+            userId: row.user_id,
+            token: row.token,
+            provider: row.provider,
+            deviceId: row.device_id,
+            deviceName: row.device_name,
+            createdAt: row.created_at,
+            updatedAt: row.updated_at,
+        }));
+    }
+    /**
+     * 获取用户的所有 Expo Token
+     */
+    getExpoTokens(userId) {
+        const rows = this.db.prepare('SELECT token FROM push_tokens WHERE user_id = ? AND provider = ?').all(userId, 'expo');
+        return rows.map(r => r.token);
+    }
+    /**
+     * 获取用户的所有 HMS Token
+     */
+    getHMSTokens(userId) {
+        const rows = this.db.prepare('SELECT token FROM push_tokens WHERE user_id = ? AND provider = ?').all(userId, 'hms');
+        return rows.map(r => r.token);
+    }
+    /**
+     * 删除指定的 Token
+     */
+    delete(token) {
+        this.db.prepare('DELETE FROM push_tokens WHERE token = ?').run(token);
+    }
+    /**
+     * 删除用户的指定 Token
+     */
+    deleteByUserAndToken(userId, token) {
+        this.db.prepare('DELETE FROM push_tokens WHERE user_id = ? AND token = ?').run(userId, token);
+    }
+    /**
+     * 删除用户的所有 Token
+     */
+    deleteByUserId(userId) {
+        this.db.prepare('DELETE FROM push_tokens WHERE user_id = ?').run(userId);
+    }
+    /**
+     * 检查 Token 是否存在
+     */
+    exists(token) {
+        const row = this.db.prepare('SELECT id FROM push_tokens WHERE token = ?').get(token);
+        return !!row;
+    }
+}

package/dist/services/task/TaskStore.js

@@ -0,0 +1,143 @@
+/**
+ * TaskStore - Gateway 任务数据访问层
+ * 操作 SQLite 数据库，与 AgentStore/SessionStore 共享同一个数据库实例
+ */
+import { getLogger } from '@pocketclaw/shared';
+import { sessionStore } from '../session/SessionStore';
+const logger = getLogger('TaskStore');
+function rowToTaskData(row) {
+    return {
+        id: row.id,
+        userId: row.user_id,
+        title: row.title,
+        description: row.description || undefined,
+        taskType: row.task_type,
+        recurrenceRule: row.recurrence_rule || undefined,
+        intervalValue: row.interval_value || undefined,
+        intervalUnit: row.interval_unit || undefined,
+        scheduledAt: row.scheduled_at,
+        startTime: row.start_time || undefined,
+        endTime: row.end_time || undefined,
+        status: row.status,
+        platformApply: row.platform_apply || undefined,
+        pushToken: row.push_token || undefined,
+        createdAt: row.created_at,
+        updatedAt: row.updated_at,
+    };
+}
+export class TaskStore {
+    db;
+    constructor(db) {
+        // 如果传入了 db 实例（测试用），直接使用
+        // 否则从 SessionStore 获取共享的数据库实例
+        if (db) {
+            this.db = db;
+        }
+        else {
+            this.db = sessionStore.getDb();
+        }
+        this.initTable();
+    }
+    initTable() {
+        this.db.exec(`
+      CREATE TABLE IF NOT EXISTS tasks (
+        id TEXT PRIMARY KEY,
+        user_id TEXT NOT NULL,
+        title TEXT NOT NULL,
+        description TEXT,
+        task_type TEXT NOT NULL DEFAULT 'one_time',
+        recurrence_rule TEXT,
+        interval_value INTEGER,
+        interval_unit TEXT,
+        scheduled_at INTEGER NOT NULL,
+        start_time INTEGER,
+        end_time INTEGER,
+        status TEXT NOT NULL DEFAULT 'pending',
+        platform_apply TEXT,
+        push_token TEXT,
+        created_at INTEGER NOT NULL,
+        updated_at INTEGER NOT NULL
+      )
+    `);
+        // 确保必要列存在（向后兼容）
+        this.ensureColumns();
+        logger.info('Tables initialized');
+    }
+    ensureColumns() {
+        const tableInfo = this.db.prepare("PRAGMA table_info(tasks)").all();
+        const columnNames = tableInfo.map((col) => col.name);
+        const requiredColumns = [
+            { name: 'platform_apply', sql: 'ALTER TABLE tasks ADD COLUMN platform_apply TEXT' },
+            { name: 'push_token', sql: 'ALTER TABLE tasks ADD COLUMN push_token TEXT' },
+            { name: 'recurrence_rule', sql: 'ALTER TABLE tasks ADD COLUMN recurrence_rule TEXT' },
+            { name: 'interval_value', sql: 'ALTER TABLE tasks ADD COLUMN interval_value INTEGER' },
+            { name: 'interval_unit', sql: 'ALTER TABLE tasks ADD COLUMN interval_unit TEXT' },
+        ];
+        for (const col of requiredColumns) {
+            if (!columnNames.includes(col.name)) {
+                this.db.exec(col.sql);
+                logger.info(`Added column: ${col.name}`);
+            }
+        }
+    }
+    // ========== Task Operations ==========
+    insert(task) {
+        this.db.prepare(`
+      INSERT INTO tasks (id, user_id, title, description, task_type, recurrence_rule, 
+        interval_value, interval_unit, scheduled_at, start_time, end_time, 
+        status, platform_apply, push_token, created_at, updated_at)
+      VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
+    `).run(task.id, task.userId, task.title, task.description || null, task.taskType, task.recurrenceRule || null, task.intervalValue || null, task.intervalUnit || null, task.scheduledAt, task.startTime || null, task.endTime || null, task.status, task.platformApply || null, task.pushToken || null, task.createdAt, task.updatedAt);
+    }
+    update(task) {
+        this.db.prepare(`
+      UPDATE tasks SET 
+        user_id = ?, title = ?, description = ?, task_type = ?, 
+        recurrence_rule = ?, interval_value = ?, interval_unit = ?,
+        scheduled_at = ?, start_time = ?, end_time = ?,
+        status = ?, platform_apply = ?, push_token = ?, updated_at = ?
+      WHERE id = ?
+    `).run(task.userId, task.title, task.description || null, task.taskType, task.recurrenceRule || null, task.intervalValue || null, task.intervalUnit || null, task.scheduledAt, task.startTime || null, task.endTime || null, task.status, task.platformApply || null, task.pushToken || null, task.updatedAt, task.id);
+    }
+    delete(id) {
+        this.db.prepare('DELETE FROM tasks WHERE id = ?').run(id);
+    }
+    findById(id) {
+        const row = this.db.prepare('SELECT * FROM tasks WHERE id = ?').get(id);
+        return row ? rowToTaskData(row) : null;
+    }
+    findByUserId(userId) {
+        const rows = this.db.prepare('SELECT * FROM tasks WHERE user_id = ? ORDER BY scheduled_at ASC').all(userId);
+        return rows.map(rowToTaskData);
+    }
+    findByStatus(status) {
+        const rows = this.db.prepare('SELECT * FROM tasks WHERE status = ? ORDER BY scheduled_at ASC').all(status);
+        return rows.map(rowToTaskData);
+    }
+    findByUserAndStatus(userId, status) {
+        const rows = this.db.prepare('SELECT * FROM tasks WHERE user_id = ? AND status = ? ORDER BY scheduled_at ASC').all(userId, status);
+        return rows.map(rowToTaskData);
+    }
+    findPendingAtTime(timestamp) {
+        // 查找状态为 pending 且计划时间 <= 指定时间戳的任务
+        const rows = this.db.prepare('SELECT * FROM tasks WHERE status = ? AND scheduled_at <= ? ORDER BY scheduled_at ASC').all('pending', timestamp);
+        return rows.map(rowToTaskData);
+    }
+    findByStatusAndBeforeTime(status, timestamp) {
+        const rows = this.db.prepare('SELECT * FROM tasks WHERE status = ? AND scheduled_at <= ? ORDER BY scheduled_at ASC').all(status, timestamp);
+        return rows.map(rowToTaskData);
+    }
+    findAll() {
+        const rows = this.db.prepare('SELECT * FROM tasks ORDER BY scheduled_at ASC').all();
+        return rows.map(rowToTaskData);
+    }
+    updateStatus(id, status) {
+        this.db.prepare('UPDATE tasks SET status = ?, updated_at = ? WHERE id = ?')
+            .run(status, Date.now(), id);
+    }
+    count() {
+        const result = this.db.prepare('SELECT COUNT(*) as count FROM tasks').get();
+        return result.count;
+    }
+}
+export const taskStore = new TaskStore();

package/dist/services/tools/calculator.js

@@ -0,0 +1,27 @@
+/**
+ * 计算器工具 - 执行数学计算
+ */
+export const calculatorTool = {
+    name: 'calculator',
+    description: '执行数学计算，支持加减乘除和括号',
+    parameters: {
+        type: 'object',
+        properties: {
+            expression: {
+                type: 'string',
+                description: '数学表达式，如: 2 + 3 * 4',
+            },
+        },
+        required: ['expression'],
+    },
+    handler: async (args) => {
+        try {
+            const expr = String(args.expression || '').replace(/[^0-9+\-*/().]/g, '');
+            const result = Function(`"use strict"; return (${expr})`)();
+            return { success: true, output: String(result) };
+        }
+        catch (error) {
+            return { success: false, errorMessage: `计算失败: ${error?.message || error}` };
+        }
+    },
+};

package/dist/services/tools/edit.js

@@ -0,0 +1,318 @@
+/**
+ * 文件编辑工具 - 行范围编辑（Plan A）
+ *
+ * 设计原则：
+ * - LLM 提供行号范围（oldRange），工具负责读取、验证、执行
+ * - 每个 edit 只处理一个行范围，多次编辑拆成多个 edit
+ * - 验证机制：LLM 可提供 oldContent 供工具比对，不匹配时返回实际内容供修正
+ * - 多 edit 时从后往前执行，避免行号偏移
+ *
+ * 安全机制：
+ * - 路径白名单校验，禁止路径穿越
+ * - 文件不存在时拒绝操作（不允许静默创建）
+ * - 目录不存在时拒绝操作（不允许递归创建目录）
+ * - 文件大小限制（默认 10MB）
+ * - 编辑操作数量限制（默认 20 个）
+ * - 编辑范围重叠检测
+ * - 敏感内容脱敏（限制错误返回中的内容长度）
+ * - 异步 I/O，不阻塞事件循环
+ *
+ * LLM 用法：
+ *   1. 先用 read 读取文件（拿到行号和内容）
+ *   2. 指定 oldRange: { startLine, endLine } + newContent
+ *   3. 可选提供 oldContent 让工具验证替换区间的实际内容
+ *   4. 验证失败时工具返回实际内容，LLM 据此修正后重试
+ */
+import fs from 'fs/promises';
+import path from 'path';
+import os from 'os';
+import { getLogger } from '@pocketclaw/shared';
+const logger = getLogger('edit');
+// ---------- 安全常量 ----------
+/** 允许访问的根目录白名单 */
+const ALLOWED_ROOTS = [
+    os.homedir(),
+    os.tmpdir(),
+    process.env.WORKSPACE_DIR || '',
+    process.env.GATEWAY_DIR || '',
+].filter(Boolean).map(p => path.resolve(p));
+/** 最大文件大小（10MB） */
+const MAX_FILE_SIZE = 10 * 1024 * 1024;
+/** 单次最大编辑操作数 */
+const MAX_EDITS = 20;
+/** 错误信息中返回的最大内容长度 */
+const MAX_ERROR_CONTENT_LENGTH = 500;
+// ---------- 安全校验 ----------
+/**
+ * 路径安全校验：检测路径穿越并验证路径在白名单内
+ */
+function isPathAllowed(filePath) {
+    // 标准化路径，解析 .. 等相对路径组件
+    const resolved = path.resolve(filePath);
+    const normalized = path.normalize(filePath);
+    // 检测路径穿越：标准化后仍包含 .. 表示非法穿越
+    if (normalized.includes('..')) {
+        return { allowed: false, reason: `路径包含穿越组件（..）: ${filePath}` };
+    }
+    // 校验路径是否在允许的根目录下
+    const isUnderAllowedRoot = ALLOWED_ROOTS.some(root => resolved.startsWith(root + path.sep) || resolved === root);
+    // if (!isUnderAllowedRoot) {
+    //   return {
+    //     allowed: false,
+    //     reason: `路径不在允许范围内: ${resolved}`,
+    //   };
+    // }
+    return { allowed: true };
+}
+/**
+ * 检测敏感文件路径
+ */
+function isSensitivePath(filePath) {
+    const lower = filePath.toLowerCase();
+    const patterns = ['.env', 'secret', 'password', 'token', 'credential', 'private_key', '.pem', '.key'];
+    return patterns.some(p => lower.includes(p));
+}
+/**
+ * 内容脱敏：敏感文件隐藏内容，大文件截断
+ */
+function sanitizeContent(content, filePath) {
+    if (isSensitivePath(filePath)) {
+        return `[敏感文件内容已隐藏，共 ${content.length} 字符]`;
+    }
+    if (content.length > MAX_ERROR_CONTENT_LENGTH) {
+        return content.slice(0, MAX_ERROR_CONTENT_LENGTH) +
+            `\n... [已截断，共 ${content.length} 字符]`;
+    }
+    return content;
+}
+// ---------- 核心逻辑 ----------
+/**
+ * 读取指定行范围（1-indexed）的原始内容
+ */
+function getRangeContent(lines, startLine, endLine) {
+    return lines.slice(startLine - 1, endLine).join('\n');
+}
+/**
+ * 执行单个行范围替换
+ */
+function applyRangeEdit(lines, startLine, endLine, newContent) {
+    const before = lines.slice(0, startLine - 1);
+    const after = lines.slice(endLine);
+    const newLines = newContent ? newContent.split('\n') : [];
+    return [...before, ...newLines, ...after];
+}
+/**
+ * 检测编辑范围是否重叠
+ */
+function hasOverlappingRanges(edits) {
+    for (let i = 0; i < edits.length; i++) {
+        for (let j = i + 1; j < edits.length; j++) {
+            const a = edits[i].oldRange;
+            const b = edits[j].oldRange;
+            if (a.startLine <= b.endLine && b.startLine <= a.endLine) {
+                return {
+                    overlap: true,
+                    message: `编辑范围重叠：edits[${i}]（第 ${a.startLine}-${a.endLine} 行）与 edits[${j}]（第 ${b.startLine}-${b.endLine} 行）重叠`,
+                };
+            }
+        }
+    }
+    return { overlap: false };
+}
+// ---------- 工具定义 ----------
+const editTool = {
+    name: 'edit',
+    description: '文件编辑工具（行范围模式）。' +
+        'LLM 先用 read 读取文件获得行号，然后指定 oldRange（起始行、结束行）和 newContent（替换后的内容）。' +
+        '可选提供 oldContent 让工具验证实际内容是否与预期一致。' +
+        '支持一次调用多个 edit（从后往前执行避免行号偏移）。',
+    parameters: {
+        type: 'object',
+        properties: {
+            path: { type: 'string', description: '文件路径' },
+            edits: {
+                type: 'array',
+                description: '编辑操作列表',
+                items: {
+                    type: 'object',
+                    description: '单个行范围编辑操作',
+                    properties: {
+                        oldRange: {
+                            type: 'object',
+                            description: '要替换的行范围（1-indexed，包含 startLine 和 endLine）',
+                            properties: {
+                                startLine: { type: 'number', description: '起始行号（1-indexed）' },
+                                endLine: { type: 'number', description: '结束行号（1-indexed，必须 >= startLine）' },
+                            },
+                            required: ['startLine', 'endLine'],
+                        },
+                        newContent: {
+                            type: 'string',
+                            description: '替换后的内容（留空或不填表示删除该行范围）',
+                        },
+                        oldContent: {
+                            type: 'string',
+                            description: '【可选】LLM 认为该范围内原有的内容。工具会比对，不一致时返回实际内容供修正',
+                        },
+                    },
+                    required: ['oldRange'],
+                },
+            }
+        },
+        required: ['path', 'edits'],
+    },
+    handler: async (args) => {
+        try {
+            const { path: filePath, edits } = args;
+            // ---- 参数校验 ----
+            if (!filePath)
+                return { success: false, errorMessage: '缺少文件路径（path）' };
+            if (!Array.isArray(edits) || edits.length === 0)
+                return { success: false, errorMessage: 'edits 必须为非空数组' };
+            for (let i = 0; i < edits.length; i++) {
+                const { oldRange } = edits[i];
+                if (!oldRange || typeof oldRange.startLine !== 'number' || typeof oldRange.endLine !== 'number')
+                    return { success: false, errorMessage: `edits[${i}]: 必须提供有效的 oldRange（startLine 和 endLine）` };
+                if (oldRange.startLine < 1)
+                    return { success: false, errorMessage: `edits[${i}]: startLine 必须 >= 1` };
+                if (oldRange.endLine < oldRange.startLine)
+                    return { success: false, errorMessage: `edits[${i}]: endLine (${oldRange.endLine}) 必须 >= startLine (${oldRange.startLine})` };
+            }
+            // ---- 路径安全校验 ----
+            const pathCheck = isPathAllowed(filePath);
+            if (!pathCheck.allowed) {
+                return { success: false, errorMessage: pathCheck.reason };
+            }
+            // ---- 文件存在性 & 大小校验 ----
+            let original;
+            try {
+                const stats = await fs.stat(filePath);
+                if (stats.size > MAX_FILE_SIZE) {
+                    return {
+                        success: false,
+                        errorMessage: `文件过大（${stats.size} 字节），超出最大允许 ${MAX_FILE_SIZE} 字节`,
+                    };
+                }
+                original = await fs.readFile(filePath, 'utf-8');
+            }
+            catch (err) {
+                if (err.code === 'ENOENT') {
+                    return { success: false, errorMessage: `文件不存在，不允许创建新文件: ${filePath}` };
+                }
+                return { success: false, errorMessage: `读取文件失败: ${err.message}` };
+            }
+            // ---- 编辑操作数量校验 ----
+            if (edits.length > MAX_EDITS) {
+                return {
+                    success: false,
+                    errorMessage: `单次最多 ${MAX_EDITS} 个编辑操作，当前 ${edits.length} 个`,
+                };
+            }
+            const origLines = original.split('\n').filter((_, i, arr) => !(i === arr.length - 1 && _ === ''));
+            const totalLines = origLines.length;
+            // ---- 验证每个 edit 的行范围 ----
+            for (let i = 0; i < edits.length; i++) {
+                const { oldRange } = edits[i];
+                if (oldRange.startLine > totalLines)
+                    return {
+                        success: false,
+                        errorMessage: `edits[${i}]: startLine=${oldRange.startLine} 超出文件总行数（${totalLines}）。`,
+                    };
+                if (oldRange.endLine > totalLines)
+                    return {
+                        success: false,
+                        errorMessage: `edits[${i}]: endLine=${oldRange.endLine} 超出文件总行数（${totalLines}）。`,
+                    };
+            }
+            // ---- 编辑范围重叠检测 ----
+            const overlapCheck = hasOverlappingRanges(edits);
+            if (overlapCheck.overlap) {
+                return { success: false, errorMessage: overlapCheck.message };
+            }
+            // ---- 验证 oldContent（如果有） ----
+            for (let i = 0; i < edits.length; i++) {
+                const { oldRange, oldContent } = edits[i];
+                if (!oldContent)
+                    continue;
+                const actualContent = getRangeContent(origLines, oldRange.startLine, oldRange.endLine);
+                if (actualContent !== oldContent) {
+                    const safeContent = sanitizeContent(actualContent, filePath);
+                    return {
+                        success: false,
+                        errorMessage: `edits[${i}]: 提供的 oldContent 与文件第 ${oldRange.startLine}-${oldRange.endLine} 行实际内容不一致。` +
+                            `工具发现的内容:\n\`\`\`\n${safeContent}\n\`\`\``,
+                    };
+                }
+            }
+            // ---- 从后往前执行替换（避免行号偏移） ----
+            let currentLines = [...origLines];
+            const sortedEdits = [...edits].sort((a, b) => b.oldRange.endLine - a.oldRange.endLine);
+            // 用 Map 记录 edit -> 原始索引（修复 indexOf 重复问题）
+            const editIndexMap = new Map();
+            edits.forEach((edit, idx) => editIndexMap.set(edit, idx));
+            const results = [];
+            for (const edit of sortedEdits) {
+                const { oldRange, newContent = '' } = edit;
+                const { startLine, endLine } = oldRange;
+                currentLines = applyRangeEdit(currentLines, startLine, endLine, newContent);
+                results.push({
+                    editIndex: editIndexMap.get(edit) ?? -1,
+                    startLine,
+                    endLine,
+                    newLines: newContent ? newContent.split('\n').length : 0,
+                });
+            }
+            const modified = currentLines.join('\n');
+            // ---- 内容未变检测 ----
+            if (modified === original) {
+                return {
+                    success: true,
+                    output: JSON.stringify({
+                        path: filePath,
+                        unchanged: true,
+                        message: '文件内容未变化，未执行写入',
+                    }),
+                };
+            }
+            // ---- 写入文件（仅当目录已存在时） ----
+            const dir = path.dirname(filePath);
+            try {
+                const dirStat = await fs.stat(dir);
+                if (!dirStat.isDirectory()) {
+                    return { success: false, errorMessage: `目标路径不是目录: ${dir}` };
+                }
+            }
+            catch (_err) {
+                return { success: false, errorMessage: `目标目录不存在，拒绝创建新目录: ${dir}` };
+            }
+            // ---- 写入修改后的内容 ----
+            await fs.writeFile(filePath, modified, 'utf-8');
+            logger.info(`edit 完成: ${filePath}`, {
+                editCount: edits.length,
+                originalSize: original.length,
+                modifiedSize: modified.length,
+                originalLines: totalLines,
+                modifiedLines: currentLines.length,
+            });
+            return {
+                success: true,
+                output: JSON.stringify({
+                    path: filePath,
+                    editCount: edits.length,
+                    stats: {
+                        originalLines: totalLines,
+                        modifiedLines: currentLines.length,
+                        linesChanged: currentLines.length - totalLines,
+                        originalSize: original.length,
+                        modifiedSize: modified.length,
+                    },
+                }),
+            };
+        }
+        catch (err) {
+            logger.error('edit 工具执行失败', { error: err.message });
+            return { success: false, errorMessage: `edit 失败: ${err.message}` };
+        }
+    },
+};
+export { editTool };