hyacinth-ai 0.9.6

package/dist/tools/git-tool.d.ts

@@ -0,0 +1,24 @@
+import type { Tool } from './interface.js';
+import { GitManager } from '../evolution/git-manager.js';
+/**
+ * GitTool — 在 Agent 工作目录中执行 Git 版本控制操作
+ *
+ * 支持 4 个 subcommand：
+ * - commit:  暂存所有变更并提交
+ * - revert:  先 stash 当前变更，再 revert 指定 commit
+ * - branch:  创建并切换到新分支
+ * - diff:    获取变更差异（支持 --stat 模式）
+ *
+ * 不在 Git 仓库中时返回友好提示。
+ * commit message 自动附加 session/turn 信息便于追溯。
+ */
+export declare class GitTool implements Tool {
+    readonly name = "git";
+    readonly description = "Git version control: commit, revert, branch, diff";
+    readonly inputSchema: Record<string, unknown>;
+    private gitManager;
+    private sessionId?;
+    constructor(gitManager: GitManager, sessionId?: string);
+    execute(args: Record<string, unknown>): Promise<string>;
+}
+//# sourceMappingURL=git-tool.d.ts.map

package/dist/tools/git-tool.js

@@ -0,0 +1,113 @@
+/**
+ * GitTool — 在 Agent 工作目录中执行 Git 版本控制操作
+ *
+ * 支持 4 个 subcommand：
+ * - commit:  暂存所有变更并提交
+ * - revert:  先 stash 当前变更，再 revert 指定 commit
+ * - branch:  创建并切换到新分支
+ * - diff:    获取变更差异（支持 --stat 模式）
+ *
+ * 不在 Git 仓库中时返回友好提示。
+ * commit message 自动附加 session/turn 信息便于追溯。
+ */
+export class GitTool {
+    name = 'git';
+    description = 'Git version control: commit, revert, branch, diff';
+    inputSchema = {
+        type: 'object',
+        properties: {
+            action: {
+                type: 'string',
+                enum: ['commit', 'revert', 'branch', 'diff'],
+                description: 'Git action to execute',
+            },
+            message: {
+                type: 'string',
+                description: 'Commit message (required for commit action)',
+            },
+            commit: {
+                type: 'string',
+                description: 'Commit hash to revert (required for revert action)',
+            },
+            name: {
+                type: 'string',
+                description: 'Branch name (required for branch action)',
+            },
+            stat: {
+                type: 'boolean',
+                description: 'Show diff stat instead of full diff (optional, for diff action)',
+            },
+            turn: {
+                type: 'number',
+                description: 'Current turn number, appended to commit message for traceability',
+            },
+        },
+        required: ['action'],
+    };
+    gitManager;
+    sessionId;
+    constructor(gitManager, sessionId) {
+        this.gitManager = gitManager;
+        this.sessionId = sessionId;
+    }
+    async execute(args) {
+        const action = args.action;
+        // 检查是否为 Git 仓库
+        if (!(await this.gitManager.isRepo())) {
+            return '当前工作目录不在 Git 仓库中';
+        }
+        switch (action) {
+            case 'commit': {
+                const message = args.message;
+                if (!message) {
+                    return "Error: 'message' parameter is required for commit action";
+                }
+                const turn = args.turn;
+                let fullMessage = message;
+                if (this.sessionId || turn !== undefined) {
+                    const tags = [];
+                    if (this.sessionId) {
+                        tags.push(`session:${this.sessionId}`);
+                    }
+                    if (turn !== undefined) {
+                        tags.push(`turn:${turn}`);
+                    }
+                    fullMessage += ` [${tags.join(' ')}]`;
+                }
+                const hash = await this.gitManager.commit(fullMessage);
+                return hash ? `Committed: ${hash}` : 'Committed (no hash returned)';
+            }
+            case 'revert': {
+                const commit = args.commit;
+                if (!commit) {
+                    return "Error: 'commit' parameter is required for revert action";
+                }
+                await this.gitManager.stash();
+                const result = await this.gitManager.revertCommit(commit);
+                return result || 'Revert completed';
+            }
+            case 'branch': {
+                const name = args.name;
+                if (!name) {
+                    return "Error: 'name' parameter is required for branch action";
+                }
+                await this.gitManager.createBranch(name);
+                return `Created and switched to branch: ${name}`;
+            }
+            case 'diff': {
+                const stat = args.stat;
+                if (stat) {
+                    const result = await this.gitManager.diffStat();
+                    return result || 'No changes';
+                }
+                else {
+                    const result = await this.gitManager.diff();
+                    return result || 'No changes';
+                }
+            }
+            default:
+                return `Error: Unknown action '${action}'. Available actions: commit, revert, branch, diff`;
+        }
+    }
+}
+//# sourceMappingURL=git-tool.js.map

package/dist/tools/glob.d.ts

@@ -0,0 +1,29 @@
+import type { Tool } from './interface.js';
+/**
+ * GlobTool — 使用 glob 模式匹配文件路径
+ *
+ * 参数：
+ * - pattern (必需): glob 匹配模式（支持 *、**、?）
+ * - path (可选): 搜索的根目录，默认为当前工作目录
+ *
+ * 返回匹配的文件路径列表（按修改时间排序），限制最大返回数量（默认 1000）
+ */
+export declare class GlobTool implements Tool {
+    readonly name = "glob";
+    readonly description = "Find files matching a glob pattern. Returns paths sorted by modification time.";
+    readonly inputSchema: Record<string, unknown>;
+    execute(args: Record<string, unknown>): Promise<string>;
+    /**
+     * 递归遍历目录，返回相对路径列表
+     */
+    private walkDir;
+    /**
+     * 将 glob 模式转换为正则表达式
+     * 支持：
+     * - **  匹配任意路径层级
+     * - *   匹配单层内的任意字符
+     * - ?   匹配单个字符
+     */
+    private globToRegex;
+}
+//# sourceMappingURL=glob.d.ts.map

package/dist/tools/glob.js

@@ -0,0 +1,152 @@
+import { promises as fs } from 'node:fs';
+import path from 'node:path';
+/**
+ * GlobTool — 使用 glob 模式匹配文件路径
+ *
+ * 参数：
+ * - pattern (必需): glob 匹配模式（支持 *、**、?）
+ * - path (可选): 搜索的根目录，默认为当前工作目录
+ *
+ * 返回匹配的文件路径列表（按修改时间排序），限制最大返回数量（默认 1000）
+ */
+export class GlobTool {
+    name = 'glob';
+    description = 'Find files matching a glob pattern. Returns paths sorted by modification time.';
+    inputSchema = {
+        type: 'object',
+        properties: {
+            pattern: {
+                type: 'string',
+                description: 'The glob pattern to match files against (e.g., "**/*.ts", "src/**/*.js")',
+            },
+            path: {
+                type: 'string',
+                description: 'The directory to search in. REQUIRED — always pass the project root directory (where package.json/tsconfig.json/etc. lives).',
+            },
+        },
+        required: ['pattern', 'path'],
+    };
+    async execute(args) {
+        const pattern = args.pattern;
+        if (!pattern)
+            return '错误：缺少 pattern 参数。请提供文件名匹配模式，例如 "**/*.ts"。';
+        const searchPath = args.path;
+        // 验证搜索路径
+        try {
+            const stat = await fs.stat(searchPath);
+            if (!stat.isDirectory()) {
+                throw new Error(`Path is not a directory: ${searchPath}`);
+            }
+        }
+        catch (error) {
+            if (error instanceof Error && error.message.startsWith('Path is not a directory')) {
+                throw error;
+            }
+            throw new Error(`Directory not found: ${searchPath}`);
+        }
+        // 递归遍历目录获取所有文件
+        const files = await this.walkDir(searchPath);
+        // 将 glob 模式转换为正则表达式并匹配
+        const regex = this.globToRegex(pattern);
+        const matches = files.filter((f) => regex.test(f.replace(/\\/g, '/')));
+        if (matches.length === 0) {
+            return 'No files matched the pattern';
+        }
+        // 获取文件修改时间并排序
+        const withStats = await Promise.all(matches.map(async (relativePath) => {
+            const fullPath = path.join(searchPath, relativePath);
+            try {
+                const stat = await fs.stat(fullPath);
+                return { path: fullPath, mtime: stat.mtime.getTime() };
+            }
+            catch {
+                return { path: fullPath, mtime: 0 };
+            }
+        }));
+        // 按修改时间降序排列（最新的在前）
+        withStats.sort((a, b) => b.mtime - a.mtime);
+        // 限制返回数量
+        const limited = withStats.slice(0, 1000);
+        return limited.map((item) => item.path).join('\n');
+    }
+    /**
+     * 递归遍历目录，返回相对路径列表
+     */
+    async walkDir(dir, basePath = '') {
+        const results = [];
+        let entries;
+        try {
+            entries = await fs.readdir(dir, { withFileTypes: true });
+        }
+        catch {
+            return results;
+        }
+        for (const entry of entries) {
+            const relativePath = basePath ? path.posix.join(basePath, entry.name) : entry.name;
+            const fullPath = path.join(dir, entry.name);
+            if (entry.isDirectory()) {
+                const subResults = await this.walkDir(fullPath, relativePath);
+                results.push(...subResults);
+            }
+            else if (entry.isFile()) {
+                results.push(relativePath);
+            }
+        }
+        return results;
+    }
+    /**
+     * 将 glob 模式转换为正则表达式
+     * 支持：
+     * - **  匹配任意路径层级
+     * - *   匹配单层内的任意字符
+     * - ?   匹配单个字符
+     */
+    globToRegex(pattern) {
+        // 统一路径分隔符
+        const normalized = pattern.replace(/\\/g, '/');
+        let regex = '';
+        let i = 0;
+        while (i < normalized.length) {
+            const c = normalized[i];
+            if (c === '*') {
+                if (normalized[i + 1] === '*') {
+                    if (normalized[i + 2] === '/') {
+                        // **/ — 匹配零或多个目录层级
+                        regex += '(?:[^/]*/)*';
+                        i += 3;
+                    }
+                    else {
+                        // ** — 匹配任意字符（含路径分隔符）
+                        regex += '.*';
+                        i += 2;
+                    }
+                }
+                else {
+                    // * — 匹配单层内的任意字符
+                    regex += '[^/]*';
+                    i++;
+                }
+            }
+            else if (c === '?') {
+                // ? — 匹配单个非路径分隔符字符
+                regex += '[^/]';
+                i++;
+            }
+            else if (c === '/') {
+                regex += '/';
+                i++;
+            }
+            else if ('.+^${}()|[]\\'.includes(c)) {
+                // 转义正则特殊字符
+                regex += '\\' + c;
+                i++;
+            }
+            else {
+                regex += c;
+                i++;
+            }
+        }
+        return new RegExp('^' + regex + '$');
+    }
+}
+//# sourceMappingURL=glob.js.map

package/dist/tools/grep.d.ts

@@ -0,0 +1,14 @@
+import type { Tool } from './interface.js';
+export type GrepOutputMode = 'content' | 'files_with_matches' | 'count';
+export declare class GrepTool implements Tool {
+    readonly name = "grep";
+    readonly description = "Search file contents with regex patterns (ripgrep). Supports file type filtering, context lines, and multiline mode.";
+    readonly inputSchema: Record<string, unknown>;
+    execute(args: Record<string, unknown>): Promise<string>;
+    private searchInFile;
+    private formatResults;
+    private walkDir;
+    private isBinaryExtension;
+    private globToRegex;
+}
+//# sourceMappingURL=grep.d.ts.map

package/dist/tools/grep.js

@@ -0,0 +1,325 @@
+import { promises as fs } from 'node:fs';
+import path from 'node:path';
+const MAX_FILE_SIZE = 1024 * 1024;
+const DEFAULT_HEAD_LIMIT = 2000; // ToolResultBuffer handles context protection
+export class GrepTool {
+    name = 'grep';
+    description = 'Search file contents with regex patterns (ripgrep). Supports file type filtering, context lines, and multiline mode.';
+    inputSchema = {
+        type: 'object',
+        properties: {
+            pattern: {
+                type: 'string',
+                description: 'The regular expression pattern to search for in file contents.',
+            },
+            path: {
+                type: 'string',
+                description: 'Directory or file to search in. REQUIRED — always pass the project root directory (where package.json/tsconfig.json/etc. lives). Searches recursively.',
+            },
+            glob: {
+                type: 'string',
+                description: 'Glob pattern to filter files (e.g. "*.js", "*.{ts,tsx}"). Only files matching this pattern will be searched.',
+            },
+            output_mode: {
+                type: 'string',
+                enum: ['content', 'files_with_matches', 'count'],
+                description: 'Output mode: "content" shows matching lines (supports -A/-B/-C context, -n line numbers, head_limit), "files_with_matches" shows file paths (supports head_limit), "count" shows match counts (supports head_limit). Defaults to "files_with_matches".',
+            },
+            '-i': {
+                type: 'boolean',
+                description: 'Case insensitive search. Default: false.',
+            },
+            '-n': {
+                type: 'boolean',
+                description: 'Show line numbers in output. Default: true for content mode.',
+            },
+            '-A': {
+                type: 'number',
+                description: 'Number of lines to show after each match.',
+            },
+            '-B': {
+                type: 'number',
+                description: 'Number of lines to show before each match.',
+            },
+            '-C': {
+                type: 'number',
+                description: 'Number of lines to show before and after each match. Shorthand for -A N -B N.',
+            },
+            head_limit: {
+                type: 'number',
+                description: 'Limit output to first N lines/entries.',
+            },
+            multiline: {
+                type: 'boolean',
+                description: 'Enable multiline mode where . matches newlines and patterns can span lines. Default: false.',
+            },
+        },
+        required: ['pattern', 'path'],
+    };
+    async execute(args) {
+        const pattern = args.pattern;
+        if (!pattern)
+            return '错误：缺少 pattern 参数。请提供正则表达式搜索模式。';
+        const searchPath = args.path;
+        const glob = args.glob;
+        const outputMode = args.output_mode ?? 'files_with_matches';
+        const caseInsensitive = args['-i'] ?? false;
+        const showLineNumbers = args['-n'] ?? true;
+        const contextAfter = args['-A'] ?? args['-C'] ?? 0;
+        const contextBefore = args['-B'] ?? args['-C'] ?? 0;
+        const headLimit = args.head_limit ?? DEFAULT_HEAD_LIMIT;
+        const multiline = args.multiline ?? false;
+        let flags = 'g';
+        if (caseInsensitive)
+            flags += 'i';
+        if (multiline)
+            flags += 's';
+        let regex;
+        try {
+            regex = new RegExp(pattern, flags);
+        }
+        catch (err) {
+            throw new Error(`Invalid regex pattern: ${err.message}`);
+        }
+        let stat;
+        try {
+            stat = await fs.stat(searchPath);
+        }
+        catch {
+            throw new Error(`Path not found: ${searchPath}`);
+        }
+        if (stat.isFile()) {
+            return await this.searchInFile(searchPath, regex, outputMode, showLineNumbers, contextBefore, contextAfter, headLimit);
+        }
+        if (!stat.isDirectory()) {
+            throw new Error(`Path is not a file or directory: ${searchPath}`);
+        }
+        const allFiles = await this.walkDir(searchPath);
+        const files = glob ? allFiles.filter((f) => this.globToRegex(glob).test(f)) : allFiles;
+        if (files.length === 0) {
+            return 'No files matched the search criteria';
+        }
+        const results = [];
+        for (const relativePath of files) {
+            const fullPath = path.join(searchPath, relativePath);
+            try {
+                const fileStat = await fs.stat(fullPath);
+                if (!fileStat.isFile() || fileStat.size > MAX_FILE_SIZE)
+                    continue;
+            }
+            catch {
+                continue;
+            }
+            try {
+                const content = await fs.readFile(fullPath, 'utf-8');
+                const allLines = content.split('\n');
+                const matches = [];
+                allLines.forEach((line, idx) => {
+                    let match;
+                    regex.lastIndex = 0;
+                    while ((match = regex.exec(line)) !== null) {
+                        matches.push({
+                            lineNumber: idx + 1,
+                            matchIndex: match.index,
+                            matchLength: match[0].length,
+                        });
+                        if (match[0].length === 0)
+                            regex.lastIndex++;
+                    }
+                });
+                if (matches.length > 0) {
+                    results.push({ filePath: fullPath, matches, allLines });
+                }
+            }
+            catch {
+                continue;
+            }
+        }
+        return this.formatResults(results, outputMode, showLineNumbers, contextBefore, contextAfter, headLimit);
+    }
+    async searchInFile(filePath, regex, outputMode, showLineNumbers, contextBefore, contextAfter, headLimit) {
+        try {
+            const content = await fs.readFile(filePath, 'utf-8');
+            const allLines = content.split('\n');
+            const matches = [];
+            allLines.forEach((line, idx) => {
+                let match;
+                regex.lastIndex = 0;
+                while ((match = regex.exec(line)) !== null) {
+                    matches.push({
+                        lineNumber: idx + 1,
+                        matchIndex: match.index,
+                        matchLength: match[0].length,
+                    });
+                    if (match[0].length === 0)
+                        regex.lastIndex++;
+                }
+            });
+            if (matches.length === 0) {
+                return `No matches found for pattern in ${filePath}`;
+            }
+            return this.formatResults([{ filePath, matches, allLines }], outputMode, showLineNumbers, contextBefore, contextAfter, headLimit);
+        }
+        catch (err) {
+            throw new Error(`Error searching file ${filePath}: ${err.message}`);
+        }
+    }
+    formatResults(results, outputMode, showLineNumbers, contextBefore, contextAfter, headLimit) {
+        if (results.length === 0) {
+            return 'No matches found';
+        }
+        if (outputMode === 'count') {
+            const lines = [];
+            let entryCount = 0;
+            for (const r of results) {
+                entryCount++;
+                if (entryCount > headLimit)
+                    break;
+                lines.push(`${r.filePath}:${r.matches.length}`);
+            }
+            if (results.length > headLimit) {
+                lines.push(`... (${results.length - headLimit} more files)`);
+            }
+            return lines.join('\n');
+        }
+        if (outputMode === 'files_with_matches') {
+            const lines = [];
+            let entryCount = 0;
+            for (const r of results) {
+                entryCount++;
+                if (entryCount > headLimit)
+                    break;
+                lines.push(r.filePath);
+            }
+            if (results.length > headLimit) {
+                lines.push(`... (${results.length - headLimit} more files)`);
+            }
+            return lines.join('\n');
+        }
+        const parts = [];
+        let totalLines = 0;
+        for (const result of results) {
+            if (totalLines >= headLimit)
+                break;
+            const multiFile = results.length > 1;
+            if (multiFile) {
+                parts.push(`--- ${result.filePath}`);
+                totalLines++;
+            }
+            const seenLines = new Set();
+            const maxLineNum = Math.max(...result.matches.map((m) => m.lineNumber + contextAfter));
+            const width = String(maxLineNum).length;
+            for (const match of result.matches) {
+                if (totalLines >= headLimit)
+                    break;
+                if (seenLines.has(match.lineNumber))
+                    continue;
+                seenLines.add(match.lineNumber);
+                const startLine = Math.max(1, match.lineNumber - contextBefore);
+                const endLine = Math.min(result.allLines.length, match.lineNumber + contextAfter);
+                if (startLine > 1 && contextBefore > 0) {
+                    parts.push('---');
+                    totalLines++;
+                }
+                for (let l = startLine; l <= endLine; l++) {
+                    if (totalLines >= headLimit) {
+                        if (parts[parts.length - 1] !== '... (output truncated)') {
+                            parts.push('... (output truncated)');
+                        }
+                        break;
+                    }
+                    const lineContent = result.allLines[l - 1] ?? '';
+                    const prefix = showLineNumbers
+                        ? `${String(l).padStart(width)}${l === match.lineNumber ? ':' : '-'}`
+                        : '';
+                    parts.push(`${prefix}${lineContent}`);
+                    totalLines++;
+                }
+            }
+        }
+        return parts.join('\n');
+    }
+    async walkDir(dir, basePath = '') {
+        const results = [];
+        let entries;
+        try {
+            entries = await fs.readdir(dir, { withFileTypes: true });
+        }
+        catch {
+            return results;
+        }
+        for (const entry of entries) {
+            if (entry.name.startsWith('.') && entry.name !== '.')
+                continue;
+            const relativePath = basePath ? path.posix.join(basePath, entry.name) : entry.name;
+            const fullPath = path.join(dir, entry.name);
+            if (entry.isDirectory()) {
+                if (entry.name === 'node_modules' || entry.name === '.git' || entry.name === 'dist' || entry.name === 'build')
+                    continue;
+                const subResults = await this.walkDir(fullPath, relativePath);
+                results.push(...subResults);
+            }
+            else if (entry.isFile()) {
+                if (this.isBinaryExtension(entry.name))
+                    continue;
+                results.push(relativePath);
+            }
+        }
+        return results;
+    }
+    isBinaryExtension(filename) {
+        const ext = path.extname(filename).toLowerCase();
+        const binaryExts = new Set([
+            '.exe', '.dll', '.so', '.dylib', '.bin', '.obj', '.o',
+            '.png', '.jpg', '.jpeg', '.gif', '.bmp', '.ico', '.webp', '.svg',
+            '.mp3', '.mp4', '.avi', '.mov', '.wmv', '.flv', '.mkv',
+            '.zip', '.tar', '.gz', '.bz2', '.7z', '.rar',
+            '.ttf', '.otf', '.woff', '.woff2',
+            '.pdf', '.doc', '.docx', '.xls', '.xlsx',
+            '.pyc', '.class', '.wasm', '.min.js',
+        ]);
+        return binaryExts.has(ext);
+    }
+    globToRegex(pattern) {
+        const normalized = pattern.replace(/\\/g, '/');
+        let regexStr = '';
+        let i = 0;
+        while (i < normalized.length) {
+            const c = normalized[i];
+            if (c === '*') {
+                if (normalized[i + 1] === '*') {
+                    if (normalized[i + 2] === '/') {
+                        regexStr += '(?:.+/)?';
+                        i += 3;
+                    }
+                    else {
+                        regexStr += '.*';
+                        i += 2;
+                    }
+                }
+                else {
+                    regexStr += '[^/]*';
+                    i++;
+                }
+            }
+            else if (c === '?') {
+                regexStr += '[^/]';
+                i++;
+            }
+            else if (c === '/') {
+                regexStr += '/';
+                i++;
+            }
+            else if ('.+^${}()|[]\\'.includes(c)) {
+                regexStr += '\\' + c;
+                i++;
+            }
+            else {
+                regexStr += c;
+                i++;
+            }
+        }
+        return new RegExp('^' + regexStr + '$');
+    }
+}
+//# sourceMappingURL=grep.js.map

package/dist/tools/http-request.d.ts

@@ -0,0 +1,14 @@
+import type { Tool } from './interface.js';
+/**
+ * HttpRequestTool — HTTP 客户端，支持 GET/POST/PUT/DELETE。
+ * 轻量爬虫 + API 调试。
+ */
+export declare class HttpRequestTool implements Tool {
+    readonly name = "http_request";
+    readonly description: string;
+    readonly inputSchema: Record<string, unknown>;
+    private static readonly DEFAULT_UA;
+    private static readonly MAX_RESPONSE_BYTES;
+    execute(args: Record<string, unknown>): Promise<string>;
+}
+//# sourceMappingURL=http-request.d.ts.map