@baitong-dev/mcp-helpers 0.0.2 → 0.0.5

package/dist/config.d.ts

@@ -1,2 +1,3 @@
 #!/usr/bin/env bun
 export declare const MCP_HOME_DIR: string;
+export declare const MCP_WORKSPACE_DIR: string;

package/dist/config.js

@@ -4,7 +4,8 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.MCP_HOME_DIR = void 0;
+exports.MCP_WORKSPACE_DIR = exports.MCP_HOME_DIR = void 0;
 const path_1 = __importDefault(require("path"));
 const os_1 = __importDefault(require("os"));
-exports.MCP_HOME_DIR = process.env.MCP_HOME_DIR || path_1.default.join(os_1.default.homedir(), '\.baitong');
+exports.MCP_HOME_DIR = process.env.MCP_HOME_DIR || path_1.default.join(os_1.default.homedir(), '.baitong');
+exports.MCP_WORKSPACE_DIR = process.env.MCP_WORKSPACE_DIR || path_1.default.resolve(path_1.default.join(exports.MCP_HOME_DIR, 'workspace'));

package/dist/{file.d.ts → file/index.d.ts}

@@ -1,10 +1,10 @@
-#!/usr/bin/env bun
+export * as Ripgrep from './ripgrep';
 /**
  * Check if a path is a directory.
  * @param path The path to check
  * @returns Whether the path is a directory
  */
-export declare function isDir(path: string): Promise<boolean>;
+export declare function isDirectory(path: string): boolean;
 /**
  * 检查一个目录是否是另一个目录的子目录
  * @param parent - 父目录路径

package/dist/file/index.js

@@ -0,0 +1,75 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Ripgrep = void 0;
+exports.isDirectory = isDirectory;
+exports.isSubdirectory = isSubdirectory;
+const path_1 = __importDefault(require("path"));
+const fs_1 = __importDefault(require("fs"));
+exports.Ripgrep = __importStar(require("./ripgrep"));
+/**
+ * Check if a path is a directory.
+ * @param path The path to check
+ * @returns Whether the path is a directory
+ */
+function isDirectory(path) {
+    try {
+        const stat = fs_1.default.statSync(path);
+        return stat.isDirectory();
+    }
+    catch {
+        return false;
+    }
+}
+/**
+ * 检查一个目录是否是另一个目录的子目录
+ * @param parent - 父目录路径
+ * @param child - 要检查的子目录路径
+ * @param options - 配置选项
+ * @param options.includeSelf - 是否将自身视为子目录
+ * @returns - 同步返回 boolean，异步返回 Promise
+ */
+function isSubdirectory(parent, child, { includeSelf = false }) {
+    const parentPath = path_1.default.resolve(parent);
+    const childPath = path_1.default.isAbsolute(child) ? child : path_1.default.join(parentPath, child);
+    const relative = path_1.default.relative(parentPath, childPath);
+    if (includeSelf && childPath === parentPath) {
+        return true;
+    }
+    return (relative && !relative.startsWith('..') && !path_1.default.isAbsolute(relative)) || false;
+}

package/dist/file/ripgrep.d.ts

@@ -0,0 +1,187 @@
+import z from 'zod';
+declare const Begin: z.ZodObject<{
+    type: z.ZodLiteral<"begin">;
+    data: z.ZodObject<{
+        path: z.ZodObject<{
+            text: z.ZodString;
+        }, z.core.$strip>;
+    }, z.core.$strip>;
+}, z.core.$strip>;
+export declare const Match: z.ZodObject<{
+    type: z.ZodLiteral<"match">;
+    data: z.ZodObject<{
+        path: z.ZodObject<{
+            text: z.ZodString;
+        }, z.core.$strip>;
+        lines: z.ZodObject<{
+            text: z.ZodString;
+        }, z.core.$strip>;
+        line_number: z.ZodNumber;
+        absolute_offset: z.ZodNumber;
+        submatches: z.ZodArray<z.ZodObject<{
+            match: z.ZodObject<{
+                text: z.ZodString;
+            }, z.core.$strip>;
+            start: z.ZodNumber;
+            end: z.ZodNumber;
+        }, z.core.$strip>>;
+    }, z.core.$strip>;
+}, z.core.$strip>;
+declare const End: z.ZodObject<{
+    type: z.ZodLiteral<"end">;
+    data: z.ZodObject<{
+        path: z.ZodObject<{
+            text: z.ZodString;
+        }, z.core.$strip>;
+        binary_offset: z.ZodNullable<z.ZodNumber>;
+        stats: z.ZodObject<{
+            elapsed: z.ZodObject<{
+                secs: z.ZodNumber;
+                nanos: z.ZodNumber;
+                human: z.ZodString;
+            }, z.core.$strip>;
+            searches: z.ZodNumber;
+            searches_with_match: z.ZodNumber;
+            bytes_searched: z.ZodNumber;
+            bytes_printed: z.ZodNumber;
+            matched_lines: z.ZodNumber;
+            matches: z.ZodNumber;
+        }, z.core.$strip>;
+    }, z.core.$strip>;
+}, z.core.$strip>;
+declare const Summary: z.ZodObject<{
+    type: z.ZodLiteral<"summary">;
+    data: z.ZodObject<{
+        elapsed_total: z.ZodObject<{
+            human: z.ZodString;
+            nanos: z.ZodNumber;
+            secs: z.ZodNumber;
+        }, z.core.$strip>;
+        stats: z.ZodObject<{
+            elapsed: z.ZodObject<{
+                secs: z.ZodNumber;
+                nanos: z.ZodNumber;
+                human: z.ZodString;
+            }, z.core.$strip>;
+            searches: z.ZodNumber;
+            searches_with_match: z.ZodNumber;
+            bytes_searched: z.ZodNumber;
+            bytes_printed: z.ZodNumber;
+            matched_lines: z.ZodNumber;
+            matches: z.ZodNumber;
+        }, z.core.$strip>;
+    }, z.core.$strip>;
+}, z.core.$strip>;
+declare const Result: z.ZodUnion<readonly [z.ZodObject<{
+    type: z.ZodLiteral<"begin">;
+    data: z.ZodObject<{
+        path: z.ZodObject<{
+            text: z.ZodString;
+        }, z.core.$strip>;
+    }, z.core.$strip>;
+}, z.core.$strip>, z.ZodObject<{
+    type: z.ZodLiteral<"match">;
+    data: z.ZodObject<{
+        path: z.ZodObject<{
+            text: z.ZodString;
+        }, z.core.$strip>;
+        lines: z.ZodObject<{
+            text: z.ZodString;
+        }, z.core.$strip>;
+        line_number: z.ZodNumber;
+        absolute_offset: z.ZodNumber;
+        submatches: z.ZodArray<z.ZodObject<{
+            match: z.ZodObject<{
+                text: z.ZodString;
+            }, z.core.$strip>;
+            start: z.ZodNumber;
+            end: z.ZodNumber;
+        }, z.core.$strip>>;
+    }, z.core.$strip>;
+}, z.core.$strip>, z.ZodObject<{
+    type: z.ZodLiteral<"end">;
+    data: z.ZodObject<{
+        path: z.ZodObject<{
+            text: z.ZodString;
+        }, z.core.$strip>;
+        binary_offset: z.ZodNullable<z.ZodNumber>;
+        stats: z.ZodObject<{
+            elapsed: z.ZodObject<{
+                secs: z.ZodNumber;
+                nanos: z.ZodNumber;
+                human: z.ZodString;
+            }, z.core.$strip>;
+            searches: z.ZodNumber;
+            searches_with_match: z.ZodNumber;
+            bytes_searched: z.ZodNumber;
+            bytes_printed: z.ZodNumber;
+            matched_lines: z.ZodNumber;
+            matches: z.ZodNumber;
+        }, z.core.$strip>;
+    }, z.core.$strip>;
+}, z.core.$strip>, z.ZodObject<{
+    type: z.ZodLiteral<"summary">;
+    data: z.ZodObject<{
+        elapsed_total: z.ZodObject<{
+            human: z.ZodString;
+            nanos: z.ZodNumber;
+            secs: z.ZodNumber;
+        }, z.core.$strip>;
+        stats: z.ZodObject<{
+            elapsed: z.ZodObject<{
+                secs: z.ZodNumber;
+                nanos: z.ZodNumber;
+                human: z.ZodString;
+            }, z.core.$strip>;
+            searches: z.ZodNumber;
+            searches_with_match: z.ZodNumber;
+            bytes_searched: z.ZodNumber;
+            bytes_printed: z.ZodNumber;
+            matched_lines: z.ZodNumber;
+            matches: z.ZodNumber;
+        }, z.core.$strip>;
+    }, z.core.$strip>;
+}, z.core.$strip>]>;
+export type Result = z.infer<typeof Result>;
+export type Match = z.infer<typeof Match>;
+export type Begin = z.infer<typeof Begin>;
+export type End = z.infer<typeof End>;
+export type Summary = z.infer<typeof Summary>;
+export declare function filepath(): Promise<string>;
+export declare function files(input: {
+    cwd: string;
+    glob?: string[];
+    hidden?: boolean;
+    follow?: boolean;
+    maxDepth?: number;
+    signal?: AbortSignal;
+}): Promise<string[]>;
+export declare function tree(input: {
+    cwd: string;
+    limit?: number;
+    signal?: AbortSignal;
+}): Promise<string>;
+export declare function search(input: {
+    cwd: string;
+    pattern: string;
+    glob?: string[];
+    limit?: number;
+    follow?: boolean;
+}): Promise<{
+    path: {
+        text: string;
+    };
+    lines: {
+        text: string;
+    };
+    line_number: number;
+    absolute_offset: number;
+    submatches: {
+        match: {
+            text: string;
+        };
+        start: number;
+        end: number;
+    }[];
+}[]>;
+export {};

package/dist/file/ripgrep.js

@@ -0,0 +1,229 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Match = void 0;
+exports.filepath = filepath;
+exports.files = files;
+exports.tree = tree;
+exports.search = search;
+const path_1 = __importDefault(require("path"));
+const promises_1 = __importDefault(require("fs/promises"));
+const zod_1 = __importDefault(require("zod"));
+const bun_1 = require("bun");
+const util_1 = require("../util");
+const process_1 = require("../process");
+const logger_1 = require("../logger");
+const simple_process_1 = require("../process/simple-process");
+const logger = new logger_1.Logger('ripgrep');
+const Stats = zod_1.default.object({
+    elapsed: zod_1.default.object({
+        secs: zod_1.default.number(),
+        nanos: zod_1.default.number(),
+        human: zod_1.default.string()
+    }),
+    searches: zod_1.default.number(),
+    searches_with_match: zod_1.default.number(),
+    bytes_searched: zod_1.default.number(),
+    bytes_printed: zod_1.default.number(),
+    matched_lines: zod_1.default.number(),
+    matches: zod_1.default.number()
+});
+const Begin = zod_1.default.object({
+    type: zod_1.default.literal('begin'),
+    data: zod_1.default.object({
+        path: zod_1.default.object({
+            text: zod_1.default.string()
+        })
+    })
+});
+exports.Match = zod_1.default.object({
+    type: zod_1.default.literal('match'),
+    data: zod_1.default.object({
+        path: zod_1.default.object({
+            text: zod_1.default.string()
+        }),
+        lines: zod_1.default.object({
+            text: zod_1.default.string()
+        }),
+        line_number: zod_1.default.number(),
+        absolute_offset: zod_1.default.number(),
+        submatches: zod_1.default.array(zod_1.default.object({
+            match: zod_1.default.object({
+                text: zod_1.default.string()
+            }),
+            start: zod_1.default.number(),
+            end: zod_1.default.number()
+        }))
+    })
+});
+const End = zod_1.default.object({
+    type: zod_1.default.literal('end'),
+    data: zod_1.default.object({
+        path: zod_1.default.object({
+            text: zod_1.default.string()
+        }),
+        binary_offset: zod_1.default.number().nullable(),
+        stats: Stats
+    })
+});
+const Summary = zod_1.default.object({
+    type: zod_1.default.literal('summary'),
+    data: zod_1.default.object({
+        elapsed_total: zod_1.default.object({
+            human: zod_1.default.string(),
+            nanos: zod_1.default.number(),
+            secs: zod_1.default.number()
+        }),
+        stats: Stats
+    })
+});
+const Result = zod_1.default.union([Begin, exports.Match, End, Summary]);
+const state = (0, util_1.lazy)(async () => {
+    if ((0, process_1.isBundledBinaryExists)('rg')) {
+        return { filepath: (0, process_1.getBundledBinaryPath)('rg') };
+    }
+    const system = Bun.which('rg');
+    if (system) {
+        const stat = await promises_1.default.stat(system).catch(() => undefined);
+        if (stat?.isFile())
+            return { filepath: system };
+        logger.warn('bun.which returned invalid rg path', { filepath: system });
+    }
+    throw new Error('rg not found');
+});
+async function filepath() {
+    const { filepath } = await state();
+    return filepath;
+}
+async function files(input) {
+    input.signal?.throwIfAborted();
+    const command = await filepath();
+    const args = ['--files', '--glob=!.git/*'];
+    if (input.follow)
+        args.push('--follow');
+    if (input.hidden !== false)
+        args.push('--hidden');
+    if (input.maxDepth !== undefined)
+        args.push(`--max-depth=${input.maxDepth}`);
+    if (input.glob) {
+        for (const g of input.glob) {
+            args.push(`--glob=${g}`);
+        }
+    }
+    // Guard against invalid cwd to provide a consistent ENOENT error.
+    if (!(await promises_1.default.stat(input.cwd).catch(() => undefined))?.isDirectory()) {
+        throw Object.assign(new Error(`No such file or directory: '${input.cwd}'`), {
+            code: 'ENOENT',
+            errno: -2,
+            path: input.cwd
+        });
+    }
+    const proc = (0, simple_process_1.spawn)(command, args, {
+        cwd: input.cwd,
+        stdout: 'pipe',
+        stderr: 'ignore',
+        abort: input.signal
+    });
+    if (!proc.stdout) {
+        throw new Error('Process output not available');
+    }
+    const results = [];
+    let buffer = '';
+    const stream = proc.stdout;
+    for await (const chunk of stream) {
+        input.signal?.throwIfAborted();
+        buffer += typeof chunk === 'string' ? chunk : chunk.toString();
+        // Handle both Unix (\n) and Windows (\r\n) line endings
+        const lines = buffer.split(/\r?\n/);
+        buffer = lines.pop() || '';
+        for (const line of lines) {
+            if (line)
+                results.push(line);
+        }
+    }
+    if (buffer)
+        results.push(buffer);
+    await proc.exited;
+    input.signal?.throwIfAborted();
+    return results;
+}
+async function tree(input) {
+    logger.info('tree', input);
+    const _files = await files({ cwd: input.cwd, signal: input.signal });
+    function dir(node, name) {
+        const existing = node.children.get(name);
+        if (existing)
+            return existing;
+        const next = { name, children: new Map() };
+        node.children.set(name, next);
+        return next;
+    }
+    const root = { name: '', children: new Map() };
+    for (const file of _files) {
+        if (file.includes('.baitong'))
+            continue;
+        const parts = file.split(path_1.default.sep);
+        if (parts.length < 2)
+            continue;
+        let node = root;
+        for (const part of parts.slice(0, -1)) {
+            node = dir(node, part);
+        }
+    }
+    function count(node) {
+        let total = 0;
+        for (const child of node.children.values()) {
+            total += 1 + count(child);
+        }
+        return total;
+    }
+    const total = count(root);
+    const limit = input.limit ?? total;
+    const lines = [];
+    const queue = [];
+    for (const child of Array.from(root.children.values()).sort((a, b) => a.name.localeCompare(b.name))) {
+        queue.push({ node: child, path: child.name });
+    }
+    let used = 0;
+    for (let i = 0; i < queue.length && used < limit; i++) {
+        const { node, path } = queue[i];
+        lines.push(path);
+        used++;
+        for (const child of Array.from(node.children.values()).sort((a, b) => a.name.localeCompare(b.name))) {
+            queue.push({ node: child, path: `${path}/${child.name}` });
+        }
+    }
+    if (total > used)
+        lines.push(`[${total - used} truncated]`);
+    return lines.join('\n');
+}
+async function search(input) {
+    const args = [`${await filepath()}`, '--json', '--hidden', "--glob='!.git/*'"];
+    if (input.follow)
+        args.push('--follow');
+    if (input.glob) {
+        for (const g of input.glob) {
+            args.push(`--glob=${g}`);
+        }
+    }
+    if (input.limit) {
+        args.push(`--max-count=${input.limit}`);
+    }
+    args.push('--');
+    args.push(input.pattern);
+    const command = args.join(' ');
+    const result = await (0, bun_1.$) `${{ raw: command }}`.cwd(input.cwd).quiet().nothrow();
+    if (result.exitCode !== 0) {
+        return [];
+    }
+    // Handle both Unix (\n) and Windows (\r\n) line endings
+    const lines = result.text().trim().split(/\r?\n/).filter(Boolean);
+    // Parse JSON lines from ripgrep output
+    return lines
+        .map(line => JSON.parse(line))
+        .map(parsed => Result.parse(parsed))
+        .filter(r => r.type === 'match')
+        .map(r => r.data);
+}

package/dist/index.d.ts

@@ -4,3 +4,4 @@ export * from './file';
 export * from './process';
 export * from './util';
 export * from './wasm';
+export * from './tools';

package/dist/index.js

@@ -20,3 +20,4 @@ __exportStar(require("./file"), exports);
 __exportStar(require("./process"), exports);
 __exportStar(require("./util"), exports);
 __exportStar(require("./wasm"), exports);
+__exportStar(require("./tools"), exports);

package/dist/logger.d.ts

@@ -0,0 +1,12 @@
+export declare class Logger {
+    private name;
+    private isProduction;
+    constructor(name: string);
+    setProductionMode(isProduction: boolean): void;
+    info(...data: any[]): void;
+    error(...data: any[]): void;
+    warn(...data: any[]): void;
+    log(...data: any[]): void;
+    debug(...data: any[]): void;
+    verbose(...data: any[]): void;
+}

package/dist/logger.js

@@ -0,0 +1,40 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Logger = void 0;
+class Logger {
+    constructor(name) {
+        this.isProduction = false;
+        this.name = name;
+    }
+    setProductionMode(isProduction) {
+        this.isProduction = isProduction;
+    }
+    info(...data) {
+        console.info(`[${this.name}][INFO]`, ...data);
+    }
+    error(...data) {
+        console.error(`[${this.name}][ERROR]`, ...data);
+    }
+    warn(...data) {
+        console.warn(`[${this.name}][WARN]`, ...data);
+    }
+    log(...data) {
+        if (this.isProduction) {
+            return;
+        }
+        console.log(`[${this.name}][LOG]`, ...data);
+    }
+    debug(...data) {
+        if (this.isProduction) {
+            return;
+        }
+        console.debug(`[${this.name}][DEBUG]`, ...data);
+    }
+    verbose(...data) {
+        if (this.isProduction) {
+            return;
+        }
+        console.log(`[${this.name}][VERBOSE]`, ...data);
+    }
+}
+exports.Logger = Logger;

package/dist/{process.d.ts → process/index.d.ts}

@@ -1,4 +1,4 @@
-#!/usr/bin/env bun
+export * as SimpleProcess from './simple-process';
 /**
  * 将 Windows 文件路径转换为 Git Bash 路径格式
  * @param path - Windows 格式的文件路径 (如 "C:\\Users")

package/dist/{process.js → process/index.js}

@@ -1,9 +1,42 @@
-#!/usr/bin/env bun
 "use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
 var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.SimpleProcess = void 0;
 exports.windowsToGitBashPath = windowsToGitBashPath;
 exports.gitBashToWindowsPath = gitBashToWindowsPath;
 exports.findGitBash = findGitBash;
@@ -11,8 +44,9 @@ exports.isBundledBinaryExists = isBundledBinaryExists;
 exports.getBundledBinaryPath = getBundledBinaryPath;
 exports.getBundledBinaryEnvs = getBundledBinaryEnvs;
 const path_1 = __importDefault(require("path"));
-const config_1 = require("./config");
+const config_1 = require("../config");
 const fs_1 = __importDefault(require("fs"));
+exports.SimpleProcess = __importStar(require("./simple-process"));
 /**
  * 将 Windows 文件路径转换为 Git Bash 路径格式
  * @param path - Windows 格式的文件路径 (如 "C:\\Users")

package/dist/process/simple-process.d.ts

@@ -0,0 +1,16 @@
+import { ChildProcess } from 'child_process';
+export type Stdio = 'inherit' | 'pipe' | 'ignore';
+export interface Options {
+    cwd?: string;
+    env?: NodeJS.ProcessEnv | null;
+    stdin?: Stdio;
+    stdout?: Stdio;
+    stderr?: Stdio;
+    abort?: AbortSignal;
+    kill?: NodeJS.Signals | number;
+    timeout?: number;
+}
+export type Child = ChildProcess & {
+    exited: Promise<number>;
+};
+export declare function spawn(command: string, args: readonly string[], options?: Options): Child;

package/dist/process/simple-process.js

@@ -0,0 +1,51 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.spawn = spawn;
+const child_process_1 = require("child_process");
+function spawn(command, args, options = {}) {
+    options.abort?.throwIfAborted();
+    const proc = (0, child_process_1.spawn)(command, args, {
+        cwd: options.cwd,
+        env: options.env === null ? {} : options.env ? { ...process.env, ...options.env } : undefined,
+        stdio: [options.stdin ?? 'ignore', options.stdout ?? 'ignore', options.stderr ?? 'ignore']
+    });
+    let aborted = false;
+    let timer;
+    const abort = () => {
+        if (aborted)
+            return;
+        if (proc.exitCode !== null || proc.signalCode !== null)
+            return;
+        aborted = true;
+        proc.kill(options.kill ?? 'SIGTERM');
+        const timeout = options.timeout ?? 5_000;
+        if (timeout <= 0)
+            return;
+        timer = setTimeout(() => {
+            proc.kill('SIGKILL');
+        }, timeout);
+    };
+    const exited = new Promise((resolve, reject) => {
+        const done = () => {
+            options.abort?.removeEventListener('abort', abort);
+            if (timer)
+                clearTimeout(timer);
+        };
+        proc.once('exit', (exitCode, signal) => {
+            done();
+            resolve(exitCode ?? (signal ? 1 : 0));
+        });
+        proc.once('error', error => {
+            done();
+            reject(error);
+        });
+    });
+    if (options.abort) {
+        options.abort.addEventListener('abort', abort, { once: true });
+        if (options.abort.aborted)
+            abort();
+    }
+    const child = proc;
+    child.exited = exited;
+    return child;
+}

package/dist/tools/index.d.ts

@@ -0,0 +1,2 @@
+export * as Tool from './tool';
+export * from './question';

package/dist/tools/index.js

@@ -0,0 +1,41 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Tool = void 0;
+exports.Tool = __importStar(require("./tool"));
+__exportStar(require("./question"), exports);

package/dist/tools/question.d.ts

@@ -0,0 +1,91 @@
+import { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js';
+import z from 'zod';
+import { Info as ToolInfo } from './tool';
+import { RequestHandlerExtra } from '@modelcontextprotocol/sdk/shared/protocol.js';
+import { ServerRequest } from '@modelcontextprotocol/sdk/types.js';
+import { ServerNotification } from '@modelcontextprotocol/sdk/types.js';
+declare const Questions: z.ZodArray<z.ZodObject<{
+    header: z.ZodString;
+    multiple: z.ZodOptional<z.ZodBoolean>;
+    options: z.ZodArray<z.ZodObject<{
+        label: z.ZodString;
+        description: z.ZodString;
+    }, z.core.$strip>>;
+    question: z.ZodString;
+}, z.core.$strip>>;
+type Questions = z.infer<typeof Questions>;
+export declare class Question {
+    static Option: z.ZodObject<{
+        label: z.ZodString;
+        description: z.ZodString;
+    }, z.core.$strip>;
+    static Info: z.ZodObject<{
+        question: z.ZodString;
+        header: z.ZodString;
+        options: z.ZodArray<z.ZodObject<{
+            label: z.ZodString;
+            description: z.ZodString;
+        }, z.core.$strip>>;
+        multiple: z.ZodOptional<z.ZodBoolean>;
+        custom: z.ZodOptional<z.ZodBoolean>;
+    }, z.core.$strip>;
+    static Questions: z.ZodArray<z.ZodObject<{
+        header: z.ZodString;
+        multiple: z.ZodOptional<z.ZodBoolean>;
+        options: z.ZodArray<z.ZodObject<{
+            label: z.ZodString;
+            description: z.ZodString;
+        }, z.core.$strip>>;
+        question: z.ZodString;
+    }, z.core.$strip>>;
+    static Answer: z.ZodArray<z.ZodString>;
+    static Answers: z.ZodArray<z.ZodArray<z.ZodString>>;
+    static InfoSchema: z.ZodObject<{
+        method: z.ZodLiteral<"question:ask">;
+        params: z.ZodObject<{
+            requestId: z.ZodString;
+            toolInfo: z.ZodObject<{
+                sessionId: z.ZodString;
+                messageId: z.ZodString;
+                callId: z.ZodString;
+            }, z.core.$strip>;
+            questions: z.ZodArray<z.ZodObject<{
+                header: z.ZodString;
+                multiple: z.ZodOptional<z.ZodBoolean>;
+                options: z.ZodArray<z.ZodObject<{
+                    label: z.ZodString;
+                    description: z.ZodString;
+                }, z.core.$strip>>;
+                question: z.ZodString;
+            }, z.core.$strip>>;
+        }, z.core.$strip>;
+    }, z.core.$strip>;
+    static AnswerSchema: z.ZodObject<{
+        method: z.ZodLiteral<"question:answer">;
+        params: z.ZodObject<{
+            requestId: z.ZodString;
+            toolInfo: z.ZodObject<{
+                sessionId: z.ZodString;
+                messageId: z.ZodString;
+                callId: z.ZodString;
+            }, z.core.$strip>;
+            answers: z.ZodArray<z.ZodArray<z.ZodString>>;
+        }, z.core.$strip>;
+    }, z.core.$strip>;
+    private _server;
+    constructor(server: McpServer);
+    /**
+     * Ask questions to the user and wait for the answers.
+     * @param questions Questions to ask
+     * @param toolInfo ToolInfo
+     * @returns Answers
+     */
+    ask(questions: Questions, toolInfo: ToolInfo, extra: RequestHandlerExtra<ServerRequest, ServerNotification>): Promise<{
+        title: string;
+        output: string;
+        metadata: {
+            answers: string[][];
+        };
+    }>;
+}
+export {};

package/dist/tools/question.js

@@ -0,0 +1,140 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Question = void 0;
+const zod_1 = __importDefault(require("zod"));
+const tool_1 = require("./tool");
+const Option = zod_1.default
+    .object({
+    label: zod_1.default.string().describe('Display text (1-5 words, concise)'),
+    description: zod_1.default.string().describe('Explanation of choice')
+})
+    .meta({
+    ref: 'QuestionOption'
+});
+const Info = zod_1.default
+    .object({
+    question: zod_1.default.string().describe('Complete question'),
+    header: zod_1.default.string().describe('Very short label (max 30 chars)'),
+    options: zod_1.default.array(Option).describe('Available choices'),
+    multiple: zod_1.default.boolean().optional().describe('Allow selecting multiple choices'),
+    custom: zod_1.default.boolean().optional().describe('Allow typing a custom answer (default: true)')
+})
+    .meta({
+    ref: 'QuestionInfo'
+});
+const Questions = zod_1.default.array(Info.omit({ custom: true })).describe('Questions to ask');
+const Answer = zod_1.default.array(zod_1.default.string()).meta({
+    ref: 'QuestionAnswer'
+});
+const Answers = zod_1.default
+    .array(Answer)
+    .describe('User answers in order of questions (each answer is an array of selected labels)');
+const InfoSchema = zod_1.default.object({
+    method: zod_1.default.literal('question:ask'),
+    params: zod_1.default.object({
+        requestId: zod_1.default.string().describe('Request ID'),
+        toolInfo: tool_1.Info,
+        questions: Questions
+    })
+});
+const AnswerSchema = zod_1.default.object({
+    method: zod_1.default.literal('question:answer'),
+    params: zod_1.default.object({
+        requestId: zod_1.default.string().describe('Request ID'),
+        toolInfo: tool_1.Info,
+        answers: Answers
+    })
+});
+class Question {
+    constructor(server) {
+        this._server = server;
+    }
+    /**
+     * Ask questions to the user and wait for the answers.
+     * @param questions Questions to ask
+     * @param toolInfo ToolInfo
+     * @returns Answers
+     */
+    async ask(questions, toolInfo, extra) {
+        if (questions.length === 0) {
+            throw new Error('At least one question is required');
+        }
+        for (const question of questions) {
+            if (question.options.length === 0) {
+                throw new Error('At least one option is required for each question');
+            }
+        }
+        const requestId = (0, tool_1.createRequestId)(extra.requestId);
+        // 开始询问问题
+        let progressTimer;
+        try {
+            const startTime = Date.now();
+            const maxWaitTime = 10 * 60 * 1000;
+            const progressToken = extra._meta?.progressToken;
+            // 不断重置超时时间，防止用户长时间不回答
+            const heartbeat = () => {
+                if (!progressToken)
+                    return;
+                progressTimer = setTimeout(() => {
+                    const waitTime = Date.now() - startTime;
+                    this._server.server.notification({
+                        method: 'notifications/progress',
+                        params: {
+                            total: maxWaitTime,
+                            progress: waitTime,
+                            progressToken
+                        }
+                    }, { relatedRequestId: extra.requestId });
+                    if (waitTime <= maxWaitTime) {
+                        heartbeat();
+                    }
+                }, 10 * 1000);
+            };
+            heartbeat();
+            // 发送问题请求并等待回答
+            const response = await this._server.server.request({
+                method: 'question:ask',
+                params: {
+                    questions,
+                    requestId,
+                    toolInfo
+                }
+            }, AnswerSchema, {
+                timeout: maxWaitTime, // 10分钟超时
+                maxTotalTimeout: maxWaitTime,
+                relatedRequestId: extra.requestId
+            });
+            const answers = response.params.answers;
+            function format(answer) {
+                if (!answer?.length)
+                    return 'Unanswered';
+                return answer.join(', ');
+            }
+            const formatted = questions
+                .map((q, i) => `"${q.question}"="${format(answers[i])}"`)
+                .join(', ');
+            const output = `User has answered your questions: ${formatted}. You can now continue with the user's answers in mind.`;
+            return {
+                title: `Asked ${questions.length} question${questions.length > 1 ? 's' : ''}`,
+                output,
+                metadata: {
+                    answers
+                }
+            };
+        }
+        finally {
+            clearTimeout(progressTimer);
+        }
+    }
+}
+exports.Question = Question;
+Question.Option = Option;
+Question.Info = Info;
+Question.Questions = Questions;
+Question.Answer = Answer;
+Question.Answers = Answers;
+Question.InfoSchema = InfoSchema;
+Question.AnswerSchema = AnswerSchema;

package/dist/tools/tool.d.ts

@@ -0,0 +1,9 @@
+import z from 'zod';
+import { RequestId } from '@modelcontextprotocol/sdk/types.js';
+export declare const Info: z.ZodObject<{
+    sessionId: z.ZodString;
+    messageId: z.ZodString;
+    callId: z.ZodString;
+}, z.core.$strip>;
+export type Info = z.infer<typeof Info>;
+export declare function createRequestId(requestId: RequestId): string;

package/dist/tools/tool.js

@@ -0,0 +1,19 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Info = void 0;
+exports.createRequestId = createRequestId;
+const zod_1 = __importDefault(require("zod"));
+const uuid_1 = require("uuid");
+exports.Info = zod_1.default
+    .object({
+    sessionId: zod_1.default.string().describe('Session ID'),
+    messageId: zod_1.default.string().describe('Message ID'),
+    callId: zod_1.default.string().describe('Tool Call ID')
+})
+    .meta({ ref: 'ToolInfo' });
+function createRequestId(requestId) {
+    return (0, uuid_1.v5)(`${requestId}-${Date.now()}`, uuid_1.v5.DNS);
+}

package/dist/util.d.ts

@@ -1,4 +1,3 @@
-#!/usr/bin/env bun
 /**
  * Lazily initialize a value.
  * @param fn A function that returns the value to be lazily initialized

package/dist/util.js

@@ -1,4 +1,3 @@
-#!/usr/bin/env bun
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.lazy = lazy;
@@ -13,15 +12,9 @@ function lazy(fn) {
     const result = () => {
         if (loaded)
             return value;
-        try {
-            value = fn();
-            loaded = true;
-            return value;
-        }
-        catch (e) {
-            // Don't mark as loaded if initialization failed
-            throw e;
-        }
+        value = fn();
+        loaded = true;
+        return value;
     };
     result.reset = () => {
         loaded = false;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@baitong-dev/mcp-helpers",
-  "version": "0.0.2",
+  "version": "0.0.5",
   "main": "./dist/index.js",
   "files": [
     "dist",
@@ -12,7 +12,8 @@
   ],
   "description": "mcp-helpers",
   "dependencies": {
-    "@modelcontextprotocol/sdk": "^1.25.1"
+    "@modelcontextprotocol/sdk": "^1.25.1",
+    "uuid": "^11.0.5"
   },
   "devDependencies": {
     "typescript": "^5.9.2"

package/dist/file.js

@@ -1,40 +0,0 @@
-#!/usr/bin/env bun
-"use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.isDir = isDir;
-exports.isSubdirectory = isSubdirectory;
-const path_1 = __importDefault(require("path"));
-/**
- * Check if a path is a directory.
- * @param path The path to check
- * @returns Whether the path is a directory
- */
-async function isDir(path) {
-    try {
-        const stat = await Bun.file(path).stat();
-        return stat.isDirectory();
-    }
-    catch {
-        return false;
-    }
-}
-/**
- * 检查一个目录是否是另一个目录的子目录
- * @param parent - 父目录路径
- * @param child - 要检查的子目录路径
- * @param options - 配置选项
- * @param options.includeSelf - 是否将自身视为子目录
- * @returns - 同步返回 boolean，异步返回 Promise
- */
-function isSubdirectory(parent, child, { includeSelf = false }) {
-    const parentPath = path_1.default.resolve(parent);
-    const childPath = path_1.default.isAbsolute(child) ? child : path_1.default.join(parentPath, child);
-    const relative = path_1.default.relative(parentPath, childPath);
-    if (includeSelf && childPath === parentPath) {
-        return true;
-    }
-    return (relative && !relative.startsWith('..') && !path_1.default.isAbsolute(relative)) || false;
-}