hyacinth-ai 0.9.6

package/dist/tools/python-bridge/parser.js

@@ -0,0 +1,258 @@
+import { readFileSync } from 'node:fs';
+import { createLogger } from '../../logging/logger.js';
+const logger = createLogger('python-parser');
+/**
+ * 从 Python 文件的 docstring 中解析工具元信息。
+ *
+ * 支持格式:
+ *   """
+ *   name: my_tool
+ *   description: 工具描述
+ *   parameters:
+ *     type: object
+ *     properties:
+ *       arg1: {type: string, description: 参数1}
+ *     required: [arg1]
+ *   """
+ */
+export function parsePythonToolMeta(filePath) {
+    let content;
+    try {
+        content = readFileSync(filePath, 'utf-8');
+    }
+    catch {
+        logger.warn(`Failed to read Python tool: ${filePath}`);
+        return null;
+    }
+    const docstring = extractDocstring(content);
+    if (!docstring) {
+        logger.debug(`No docstring found in ${filePath}`);
+        return null;
+    }
+    try {
+        const meta = parseYamlLike(docstring);
+        if (!meta.name || !meta.description) {
+            logger.warn(`Python tool ${filePath} missing required 'name' or 'description' in docstring`);
+            return null;
+        }
+        return meta;
+    }
+    catch (err) {
+        logger.warn(`Failed to parse docstring in ${filePath}: ${err.message}`);
+        return null;
+    }
+}
+/** 提取第一个 triple-quoted docstring */
+function extractDocstring(content) {
+    // 匹配 """...""" 或 '''...'''
+    const m = content.match(/"""([^"]*)"""/s) ?? content.match(/'''([^']*)'''/s);
+    return m ? m[1].trim() : null;
+}
+/** 简单 YAML-like 解析：缩进层级 + 键值对 + 大括号块 */
+function parseYamlLike(text) {
+    const result = { name: '', description: '', inputSchema: { type: 'object', properties: {} } };
+    const lines = text.split('\n');
+    let i = 0;
+    while (i < lines.length) {
+        const line = lines[i];
+        // 跳过空行和注释
+        if (!line.trim() || line.trim().startsWith('#')) {
+            i++;
+            continue;
+        }
+        const colonIdx = line.indexOf(':');
+        if (colonIdx === -1) {
+            i++;
+            continue;
+        }
+        const key = line.slice(0, colonIdx).trim();
+        const rest = line.slice(colonIdx + 1).trim();
+        if (key === 'name') {
+            result.name = rest;
+            i++;
+        }
+        else if (key === 'description') {
+            let desc = rest;
+            // 多行描述：后续以同缩进或更深缩进开头的非键值行
+            const baseIndent = line.match(/^(\s*)/)?.[1].length ?? 0;
+            i++;
+            while (i < lines.length) {
+                const nextLine = lines[i];
+                const nextIndent = nextLine.match(/^(\s*)/)?.[1].length ?? 0;
+                const nextColon = nextLine.indexOf(':');
+                // 如果下一行缩进更深且不是新的键值对，追加到描述
+                if (nextIndent > baseIndent && (nextColon === -1 || nextIndent >= nextLine.indexOf(':'))) {
+                    desc += '\n' + nextLine.trimStart();
+                    i++;
+                }
+                else {
+                    break;
+                }
+            }
+            result.description = desc;
+        }
+        else if (key === 'parameters') {
+            // 找 parameters 块：收集从下一行开始直到缩进回归的所有行
+            const blockLines = [];
+            const baseIndent = line.match(/^(\s*)/)?.[1].length ?? 0;
+            i++;
+            while (i < lines.length) {
+                const nextLine = lines[i];
+                const nextIndent = nextLine.match(/^(\s*)/)?.[1].length ?? 0;
+                if (nextIndent <= baseIndent && nextLine.trim())
+                    break; // 缩进回归，参数块结束
+                blockLines.push(nextLine);
+                i++;
+            }
+            const schemaText = blockLines.join('\n').trim();
+            if (schemaText) {
+                try {
+                    result.inputSchema = parseJsonLike(schemaText);
+                }
+                catch {
+                    // 解析失败，保留默认 schema
+                    logger.warn('Failed to parse parameters block, using default schema');
+                }
+            }
+        }
+        else {
+            i++;
+        }
+    }
+    return result;
+}
+/** 将缩进 YAML-like 的 parameters 块转为 JSON Schema 对象 */
+function parseJsonLike(text) {
+    // Step 1: 将缩进格式转为 JSON 字符串
+    const lines = text.split('\n');
+    const jsonLines = convertToJsonLines(lines);
+    try {
+        return JSON.parse(jsonLines);
+    }
+    catch {
+        // 嵌套花括号可能被分割, 尝试手动构建
+    }
+    return { type: 'object', properties: {} };
+}
+function convertToJsonLines(lines) {
+    const parts = [];
+    let i = 0;
+    const indentStack = [];
+    // 标记：下一个 item 是否需要前导逗号
+    let needsComma = false;
+    while (i < lines.length) {
+        const line = lines[i];
+        const trimmed = line.trim();
+        if (!trimmed) {
+            i++;
+            continue;
+        }
+        const indent = line.match(/^(\s*)/)?.[1].length ?? 0;
+        // 关闭更深的块
+        while (indentStack.length > 0 && indent <= indentStack[indentStack.length - 1]) {
+            parts.push('}');
+            indentStack.pop();
+            needsComma = true; // 块关闭后，下一个同层 item 需要逗号
+        }
+        const colonIdx = trimmed.indexOf(':');
+        if (colonIdx === -1) {
+            i++;
+            continue;
+        }
+        const key = trimmed.slice(0, colonIdx).trim();
+        let val = trimmed.slice(colonIdx + 1).trim();
+        // 去掉尾部的逗号（支持 YAML-like trailing comma）
+        if (val.endsWith(','))
+            val = val.slice(0, -1);
+        if (val === '{') {
+            // 开始一个新的嵌套对象
+            const keyQuoted = /^\w+$/.test(key) ? `"${key}"` : key;
+            parts.push(`${needsComma ? ', ' : ''}${keyQuoted}: {`);
+            indentStack.push(indent);
+            needsComma = false; // 刚打开的块内部不需要逗号
+        }
+        else if (!val || (val.startsWith('{') && !val.endsWith('}'))) {
+            // 空值或残缺的内联对象 → 检查下一行是否有更深缩进
+            const hasDeeperBlock = i + 1 < lines.length &&
+                (lines[i + 1].match(/^(\s*)/)?.[1].length ?? 0) > indent;
+            if (hasDeeperBlock) {
+                const keyQuoted = /^\w+$/.test(key) ? `"${key}"` : key;
+                parts.push(`${needsComma ? ', ' : ''}${keyQuoted}: {`);
+                indentStack.push(indent);
+                needsComma = false;
+            }
+            else {
+                const keyQuoted = /^\w+$/.test(key) ? `"${key}"` : key;
+                parts.push(`${needsComma ? ', ' : ''}${keyQuoted}: ${formatJsonValue(val)}`);
+                needsComma = true;
+            }
+        }
+        else if (val.startsWith('{') && val.endsWith('}')) {
+            // 单行对象: key: { ... }
+            const keyQuoted = /^\w+$/.test(key) ? `"${key}"` : key;
+            parts.push(`${needsComma ? ', ' : ''}${keyQuoted}: ${formatJsonValue(val)}`);
+            needsComma = true;
+        }
+        else if (val.startsWith('[') && val.endsWith(']')) {
+            // 数组值
+            const keyQuoted = /^\w+$/.test(key) ? `"${key}"` : key;
+            const arrItems = val.slice(1, -1).split(',').map(s => s.trim()).map(s => /^\w+$/.test(s) ? `"${s}"` : s).join(', ');
+            parts.push(`${needsComma ? ', ' : ''}${keyQuoted}: [${arrItems}]`);
+            needsComma = true;
+        }
+        else {
+            // 普通键值对
+            const keyQuoted = /^\w+$/.test(key) ? `"${key}"` : key;
+            parts.push(`${needsComma ? ', ' : ''}${keyQuoted}: ${formatJsonValue(val)}`);
+            needsComma = true;
+        }
+        i++;
+    }
+    // 关闭所有未闭合的块
+    while (indentStack.length > 0) {
+        parts.push('}');
+        indentStack.pop();
+    }
+    return `{${parts.join('')}}`;
+}
+function formatJsonValue(val) {
+    if (val === 'true' || val === 'false')
+        return val;
+    if (val === 'null')
+        return 'null';
+    if (/^-?\d+(\.\d+)?$/.test(val))
+        return val;
+    // 内联 YAML-like 对象: {key: val, key2: val2}
+    if (val.startsWith('{') && val.endsWith('}')) {
+        const obj = parseInlineYamlObject(val);
+        if (obj)
+            return JSON.stringify(obj);
+    }
+    // 字符串：引号包裹，转义内部引号
+    const escaped = val.replace(/"/g, '\\"');
+    return `"${escaped}"`;
+}
+/** 将内联 YAML-like 对象 {key: val, key: val} 解析为真正的 JS 对象 */
+function parseInlineYamlObject(text) {
+    try {
+        const inner = text.slice(1, -1).trim();
+        if (!inner)
+            return {};
+        const result = {};
+        // 按逗号分割，但只在逗号后紧跟 "单词:" 模式时才算真正的分隔
+        const segments = inner.split(/,\s*(?=\w+\s*:)/);
+        for (const seg of segments) {
+            const colonIdx = seg.indexOf(':');
+            if (colonIdx === -1)
+                continue;
+            const key = seg.slice(0, colonIdx).trim();
+            const val = seg.slice(colonIdx + 1).trim();
+            result[key] = val;
+        }
+        return result;
+    }
+    catch {
+        return null;
+    }
+}
+//# sourceMappingURL=parser.js.map

package/dist/tools/read.d.ts

@@ -0,0 +1,16 @@
+import type { Tool } from './interface.js';
+/** 图片处理器 — 将 read 工具输出的图片注入到 ImageStore */
+export interface ImageHandler {
+    store(base64Data: string, mediaType: string, sourcePath: string): string;
+    inject(imgId: string, data: string, mediaType: string): void;
+}
+export declare class ReadTool implements Tool {
+    readonly name = "read";
+    readonly description = "Read a file from disk. Supports offset/limit for chunked reading. Images return dimensions, PDFs return page count. Max 2000 lines per read \u2014 use offset+limit for large files.";
+    readonly companionDescription = "\u9700\u8981\u770B\u70B9\u522B\u7684\u4E1C\u897F\u4E86\u3002";
+    readonly inputSchema: Record<string, unknown>;
+    private imageHandler;
+    setImageHandler(handler: ImageHandler): void;
+    execute(args: Record<string, unknown>): Promise<string>;
+}
+//# sourceMappingURL=read.d.ts.map

package/dist/tools/read.js

@@ -0,0 +1,276 @@
+import { createReadStream, promises as fs } from 'node:fs';
+import { createInterface } from 'node:readline';
+import { recordFileRead } from './file-tracker.js';
+// ── 常量 ────────────────────────────────────────────────────────
+const DEFAULT_LIMIT = 2000;
+const MAX_LIMIT = 2000;
+const BINARY_SNIFF_BYTES = 512;
+const TEXT_HINT_THRESHOLD = 10 * 1024 * 1024; // 10MB
+const IMAGE_SIGNATURES = [
+    { ext: 'png', mime: 'image/png', bytes: [0x89, 0x50, 0x4E, 0x47], offset: 0 },
+    { ext: 'jpg', mime: 'image/jpeg', bytes: [0xFF, 0xD8, 0xFF], offset: 0 },
+    { ext: 'gif', mime: 'image/gif', bytes: [0x47, 0x49, 0x46, 0x38], offset: 0 },
+    { ext: 'webp', mime: 'image/webp', bytes: [0x52, 0x49, 0x46, 0x46], offset: 0 },
+    { ext: 'bmp', mime: 'image/bmp', bytes: [0x42, 0x4D], offset: 0 },
+];
+// ── 二进制检测 ──────────────────────────────────────────────────
+function hasNullBytes(buf, length) {
+    for (let i = 0; i < length; i++)
+        if (buf[i] === 0)
+            return true;
+    return false;
+}
+function matchSignature(buf, sig) {
+    if (buf.length < sig.offset + sig.bytes.length)
+        return false;
+    return sig.bytes.every((b, i) => buf[sig.offset + i] === b);
+}
+function detectImageType(buf) {
+    for (const sig of IMAGE_SIGNATURES) {
+        if (matchSignature(buf, sig)) {
+            if (sig.ext === 'webp' && buf.length >= 12) {
+                if (buf[8] === 0x57 && buf[9] === 0x45 && buf[10] === 0x42 && buf[11] === 0x50)
+                    return sig;
+                continue;
+            }
+            return sig;
+        }
+    }
+    return null;
+}
+function isPdf(buf) {
+    return buf.length >= 5 && buf[0] === 0x25 && buf[1] === 0x50 && buf[2] === 0x44 && buf[3] === 0x46;
+}
+// ── 图片尺寸提取（仅读文件头，不加载像素数据）───────────────────
+async function getImageDimensions(filePath, type) {
+    try {
+        const fh = await fs.open(filePath, 'r');
+        try {
+            const buf = Buffer.alloc(64);
+            await fh.read(buf, 0, 64, 0);
+            switch (type) {
+                case 'png':
+                    if (buf.length >= 24)
+                        return { width: buf.readUInt32BE(16), height: buf.readUInt32BE(20) };
+                    break;
+                case 'jpg':
+                    for (let i = 2; i < buf.length - 9; i++) {
+                        if (buf[i] === 0xFF && buf[i + 1] === 0xC0) {
+                            return { height: buf.readUInt16BE(i + 5), width: buf.readUInt16BE(i + 7) };
+                        }
+                    }
+                    break;
+                case 'gif':
+                    if (buf.length >= 10)
+                        return { width: buf.readUInt16LE(6), height: buf.readUInt16LE(8) };
+                    break;
+                case 'bmp':
+                    if (buf.length >= 26)
+                        return { width: buf.readInt32LE(18), height: buf.readInt32LE(22) };
+                    break;
+                case 'webp':
+                    if (buf.length >= 30) {
+                        if (buf[12] === 0x56 && buf[13] === 0x50 && buf[14] === 0x38 && buf[15] === 0x20) {
+                            return { width: buf.readUInt16LE(26) & 0x3FFF, height: buf.readUInt16LE(28) & 0x3FFF };
+                        }
+                        if (buf[12] === 0x56 && buf[13] === 0x50 && buf[14] === 0x38 && buf[15] === 0x4C) {
+                            const bits = buf.readUInt32LE(21);
+                            return { width: (bits & 0x3FFF) + 1, height: ((bits >> 14) & 0x3FFF) + 1 };
+                        }
+                        if (buf[12] === 0x56 && buf[13] === 0x50 && buf[14] === 0x38 && buf[15] === 0x58) {
+                            return { width: (buf.readUIntLE(24, 3) & 0xFFFFFF) + 1, height: (buf.readUIntLE(27, 3) & 0xFFFFFF) + 1 };
+                        }
+                    }
+                    break;
+            }
+        }
+        finally {
+            await fh.close();
+        }
+    }
+    catch { /* degrade */ }
+    return null;
+}
+// ── PDF trailer 页数（仅读尾部 8KB，不上全量）────────────────────
+async function getPdfPageCount(filePath, fileSize) {
+    try {
+        const size = typeof fileSize === 'bigint' ? Number(fileSize) : fileSize;
+        const tailSize = Math.min(8192, size);
+        const fh = await fs.open(filePath, 'r');
+        try {
+            const buf = Buffer.alloc(tailSize);
+            await fh.read(buf, 0, tailSize, size - tailSize);
+            const tail = buf.toString('latin1');
+            const m = tail.match(/\/Count\s+(\d+)/);
+            if (m) {
+                const n = parseInt(m[1], 10);
+                if (n > 0)
+                    return n;
+            }
+        }
+        finally {
+            await fh.close();
+        }
+    }
+    catch { /* degrade */ }
+    return null;
+}
+// ── 格式化 ──────────────────────────────────────────────────────
+function formatLines(startLine, lines) {
+    const width = String(startLine + lines.length - 1).length;
+    return lines.map((line, i) => String(startLine + i).padStart(width) + '→' + line).join('\n');
+}
+function formatFileSize(bytes) {
+    const n = typeof bytes === 'bigint' ? Number(bytes) : bytes;
+    if (n < 1024)
+        return `${n}B`;
+    if (n < 1024 * 1024)
+        return `${(n / 1024).toFixed(1)}KB`;
+    return `${(n / (1024 * 1024)).toFixed(2)}MB`;
+}
+// ── 流式文本读取 ────────────────────────────────────────────────
+async function readTextLines(filePath, offset, limit, fileSize) {
+    const safeLimit = Math.max(1, Math.min(limit, MAX_LIMIT));
+    const startLine = Math.max(1, offset);
+    const endLine = startLine + safeLimit - 1;
+    const resultLines = [];
+    let totalLines = 0;
+    const rl = createInterface({
+        input: createReadStream(filePath, { encoding: 'utf-8' }),
+        crlfDelay: Infinity,
+    });
+    for await (const rawLine of rl) {
+        totalLines++;
+        if (totalLines >= startLine && totalLines <= endLine)
+            resultLines.push(rawLine);
+        if (totalLines >= endLine) {
+            rl.close();
+            break;
+        }
+    }
+    rl.close();
+    if (resultLines.length === 0) {
+        return `(empty) offset=${offset} exceeds file (total: ${totalLines} lines)`;
+    }
+    const sizeNum = typeof fileSize === 'bigint' ? Number(fileSize) : fileSize;
+    let output = formatLines(startLine, resultLines);
+    if (sizeNum > TEXT_HINT_THRESHOLD && totalLines >= endLine) {
+        output += `\n\n(file ${formatFileSize(fileSize)}, lines ${startLine}-${startLine + resultLines.length - 1} of ${totalLines}+. Use offset=${startLine + resultLines.length} for next chunk)`;
+    }
+    return output;
+}
+// ── 图片 / PDF 读取 ─────────────────────────────────────────────
+async function readImage(filePath, imageType, stat, returnBase64 = false, imageHandler) {
+    const dims = await getImageDimensions(filePath, imageType.ext);
+    const parts = [
+        `[Image: ${imageType.ext.toUpperCase()}]`,
+        `Size: ${formatFileSize(stat.size)}`,
+    ];
+    if (dims)
+        parts.push(`Dimensions: ${dims.width}x${dims.height}px`);
+    else
+        parts.push(`Dimensions: (unable to parse)`);
+    if (returnBase64) {
+        const fh = await fs.open(filePath, 'r');
+        const buf = Buffer.alloc(stat.size);
+        await fh.read(buf, 0, stat.size, 0);
+        await fh.close();
+        const b64 = buf.toString('base64');
+        // 通过 ImageHandler 注入到 ImageStore，下一轮 compose 时自动作为 ImageContent 发送
+        if (imageHandler) {
+            const imgId = imageHandler.store(b64, imageType.mime, filePath);
+            imageHandler.inject(imgId, b64, imageType.mime);
+            parts.push(`Data: data:${imageType.mime};base64,${b64.slice(0, 200)}...`);
+            parts.push(`Image #${imgId} injected — visible to vision models in next response.`);
+        }
+        else {
+            parts.push(`Data: data:${imageType.mime};base64,${b64}`);
+        }
+    }
+    else {
+        parts.push('(metadata only, pixel data not loaded — use return_base64:true for vision models)');
+    }
+    return parts.join('\n');
+}
+async function readPdf(filePath, stat) {
+    const pageCount = await getPdfPageCount(filePath, stat.size);
+    const parts = [
+        `[PDF Document]`,
+        `Size: ${formatFileSize(stat.size)}`,
+    ];
+    if (pageCount !== null)
+        parts.push(`Pages: ${pageCount}`);
+    parts.push('(use a PDF MCP server for text/image extraction)');
+    return parts.join('\n');
+}
+// ── ReadTool ────────────────────────────────────────────────────
+export class ReadTool {
+    name = 'read';
+    description = 'Read a file from disk. Supports offset/limit for chunked reading. Images return dimensions, PDFs return page count. Max 2000 lines per read — use offset+limit for large files.';
+    companionDescription = '需要看点别的东西了。';
+    inputSchema = {
+        type: 'object',
+        properties: {
+            file_path: {
+                type: 'string',
+                description: 'The absolute path to the file to read',
+            },
+            offset: {
+                type: 'number',
+                description: 'Line number to start reading from (1-based). Default 1.',
+            },
+            limit: {
+                type: 'number',
+                description: 'Maximum number of lines to read (1-2000, default 2000).',
+            },
+            return_base64: {
+                type: 'boolean',
+                description: 'For image files: return full base64-encoded data for use with vision models. For text files: ignored.',
+            },
+        },
+        required: ['file_path'],
+    };
+    imageHandler = null;
+    setImageHandler(handler) {
+        this.imageHandler = handler;
+    }
+    async execute(args) {
+        const filePath = args.file_path;
+        if (!filePath)
+            return '错误：缺少 file_path 参数。请提供文件的绝对路径。';
+        const offset = Math.max(1, args.offset ?? 1);
+        const limit = Math.max(1, Math.min(args.limit ?? DEFAULT_LIMIT, MAX_LIMIT));
+        let stat;
+        try {
+            stat = await fs.stat(filePath);
+        }
+        catch {
+            throw new Error(`File not found: ${filePath}`);
+        }
+        if (!stat.isFile())
+            throw new Error(`Path is not a file: ${filePath}`);
+        // 记录文件已被读取（支撑 write/edit 的 read-before-write 门控）
+        recordFileRead(filePath);
+        // sniff 512 bytes for type detection
+        try {
+            const sniffBuf = Buffer.alloc(BINARY_SNIFF_BYTES);
+            const sniffFh = await fs.open(filePath, 'r');
+            const { bytesRead } = await sniffFh.read(sniffBuf, 0, BINARY_SNIFF_BYTES, 0);
+            await sniffFh.close();
+            const imageType = detectImageType(sniffBuf);
+            if (imageType)
+                return readImage(filePath, imageType, stat, !!args.return_base64, this.imageHandler);
+            if (isPdf(sniffBuf))
+                return readPdf(filePath, stat);
+            if (hasNullBytes(sniffBuf, bytesRead)) {
+                return `[Binary File]\nSize: ${formatFileSize(stat.size)}\nBinary data detected, cannot display as text.`;
+            }
+        }
+        catch (err) {
+            if (err instanceof Error && err.message.startsWith('File not found'))
+                throw err;
+        }
+        return readTextLines(filePath, offset, limit, stat.size);
+    }
+}
+//# sourceMappingURL=read.js.map

package/dist/tools/registry.d.ts

@@ -0,0 +1,2 @@
+export { ToolRegistry } from '../registry/tool.registry.js';
+//# sourceMappingURL=registry.d.ts.map

package/dist/tools/registry.js

@@ -0,0 +1,2 @@
+export { ToolRegistry } from '../registry/tool.registry.js';
+//# sourceMappingURL=registry.js.map

package/dist/tools/restart.d.ts

@@ -0,0 +1,10 @@
+import type { Tool } from './interface.js';
+export declare class RestartTool implements Tool {
+    private cwd;
+    readonly name = "restart";
+    readonly description: string;
+    readonly inputSchema: Record<string, unknown>;
+    constructor(cwd: string);
+    execute(args: Record<string, unknown>): Promise<string>;
+}
+//# sourceMappingURL=restart.d.ts.map

package/dist/tools/restart.js

@@ -0,0 +1,46 @@
+import { writeFileSync, mkdirSync } from 'node:fs';
+import { join } from 'node:path';
+import { homedir } from 'node:os';
+const RESTART_EXIT_CODE = 42;
+const RESTART_FILE = '.agent/.restart-session';
+const CONTINUATION_FILE = '.agent/.restart-continuation';
+export class RestartTool {
+    cwd;
+    name = 'restart';
+    description = 'Restart the Agent process. The current session is persisted and resumed automatically after restart. ' +
+        'Config is saved, child processes are stopped gracefully.\n' +
+        'Optional parameter "message": if provided, this message will be automatically sent after restart to continue work. ' +
+        'If omitted, the agent will wait for user input after restart.';
+    inputSchema = {
+        type: 'object',
+        properties: {
+            message: {
+                type: 'string',
+                description: 'Optional. After restart, this message will be automatically sent to continue working (e.g. "继续测试"). Omit to wait for user input.',
+            },
+        },
+    };
+    constructor(cwd) {
+        this.cwd = cwd;
+    }
+    async execute(args) {
+        const agentDir = join(homedir(), '.agent');
+        try {
+            mkdirSync(agentDir, { recursive: true });
+            // 标记文件告诉 guardian 使用 --continue
+            writeFileSync(join(agentDir, '.restart-session'), 'true', 'utf-8');
+            // 如果传了 message，保存续工指令
+            const message = args.message;
+            if (message) {
+                writeFileSync(join(agentDir, '.restart-continuation'), message, 'utf-8');
+            }
+        }
+        catch { }
+        setTimeout(() => process.exit(RESTART_EXIT_CODE), 500);
+        if (args.message) {
+            return `Restarting... "${args.message.slice(0, 60)}" will be executed after restart.`;
+        }
+        return 'Restarting... Session will be resumed.';
+    }
+}
+//# sourceMappingURL=restart.js.map

package/dist/tools/result-buffer.d.ts

@@ -0,0 +1,66 @@
+export interface ResultBufferConfig {
+    /** Session directory for storing buffered files (auto-creates `buffered-results/` subdir). */
+    sessionDir: string;
+    /** Whether buffering is enabled. Default true. */
+    enabled?: boolean;
+    /** Size threshold in bytes. Results larger than this are buffered. Default 16384 (16 KB). */
+    threshold?: number;
+    /** Include a preview of the first N characters in the pointer message. Default true. */
+    includePreview?: boolean;
+    /** Number of characters to include in preview. Default 500. */
+    previewChars?: number;
+}
+/**
+ * ToolResultBuffer — 通用工具结果中间层
+ *
+ * 所有工具（内置 / MCP / 插件 / Skill）的执行结果在注入对话历史前经过此类。
+ * 当结果字节数超过阈值时，将完整结果写入磁盘缓冲文件，对话中仅注入一条短的
+ * "指针消息"。LLM 通过已有的 `read` 工具（含 offset/limit 分页）按需读取。
+ *
+ * 对标 StormBreaker 模式：AgentLoop 构造函数内自初始化，不需要 factory.ts 注入。
+ *
+ * 七条原则自检（§0.5）：
+ *   ① 单一职责 — 只做"大结果→文件，小结果→透传"
+ *   ② 零侵入   — 删除此文件 + 移除 loop.ts 调用→系统正常运行
+ *   ③ 外部配置 — 阈值通过 configCenter 控制
+ *   ④ 数据分离 — 数据（缓冲文件）/ 配置（阈值）/ 代码（buffer 逻辑）
+ *   ⑤ 接口稳定 — 唯一入口 maybeBuffer(result, toolName): string
+ *   ⑥ 可独立测试 — 构造字符串→调 maybeBuffer→验证文件和指针格式
+ *   ⑦ 跨项目可移植 — 复制到任何 Agent 项目即可用
+ */
+export declare class ToolResultBuffer {
+    private sessionDir;
+    private enabled;
+    private threshold;
+    private includePreview;
+    private previewChars;
+    private bufferDir;
+    private initialized;
+    constructor(config: ResultBufferConfig);
+    /**
+     * 如果 `result` 超过阈值，写入磁盘并返回指针消息；否则原样返回。
+     * 先折叠连续重复行（日志/错误输出优化），再判断是否需要缓冲。
+     *
+     * @param result  工具执行返回的原始文本
+     * @param toolName  工具名（用于指针消息和文件名，如 `mcp__chrome-devtools__take_snapshot`）
+     * @returns 原始结果（≤阈值）或指针消息（>阈值）
+     */
+    maybeBuffer(result: string, toolName: string): string;
+    /** 写入缓冲文件并生成指针消息。首次调用时懒创建缓冲目录。 */
+    private bufferToDisk;
+    private ensureDir;
+    /** 生成唯一文件名：`工具名-时间戳-短哈希.txt` */
+    private buildFilename;
+    /** FNV-1a 32-bit hash — 轻量、确定性、零依赖 */
+    private fnv32a;
+    /**
+     * 折叠连续重复行。当同一行连续出现 ≥5 次时，压缩为 "[×N] content"。
+     * 针对日志、错误输出等包含大量重复内容的场景，大幅减少 token 消耗。
+     */
+    private foldRepeatedLines;
+    /** 获取缓冲目录路径（用于外部判断文件是否已缓冲）。 */
+    getBufferDir(): string;
+    /** 生成 LLM 可读的指针消息，引导其使用 `read` 工具按需读取。 */
+    private buildPointerMessage;
+}
+//# sourceMappingURL=result-buffer.d.ts.map