@baitong-dev/mcp-helpers 0.0.1 → 0.0.3

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,4 +1,4 @@
-#!/usr/bin/env bun
+export * as Ripgrep from './ripgrep';
 /**
  * Check if a path is a directory.
  * @param path The path to check

package/dist/file/index.js

@@ -0,0 +1,74 @@
+"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.isDir = isDir;
+exports.isSubdirectory = isSubdirectory;
+const path_1 = __importDefault(require("path"));
+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
+ */
+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;
+}

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/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")
@@ -17,18 +17,11 @@ export declare function findGitBash(customPath?: string | null): string | null;
  * @param name Binary Name
  * @returns Whether the binary exists
  */
-export declare function isBinaryExists(name: string): boolean;
+export declare function isBundledBinaryExists(name: string): boolean;
 /**
  * Get full path to a bundled binary
  * @param name Binary Name
  * @returns Full path to the binary
  */
 export declare function getBundledBinaryPath(name?: string): string;
-export declare function getBinaryEnvs(): {
-    PATH: string;
-    NODE: string;
-    npm_config_globalconfig: string;
-    npm_config_global_prefix: string;
-    npm_config_prefix: string;
-    npm_node_execpath: string;
-};
+export declare function getBundledBinaryEnvs(): Record<string, string>;

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

@@ -1,18 +1,52 @@
-#!/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;
-exports.isBinaryExists = isBinaryExists;
+exports.isBundledBinaryExists = isBundledBinaryExists;
 exports.getBundledBinaryPath = getBundledBinaryPath;
-exports.getBinaryEnvs = getBinaryEnvs;
+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")
@@ -127,7 +161,10 @@ function findGitBash(customPath) {
  * @param name Binary Name
  * @returns Binary Name with .exe extension on Windows
  */
-function getBinaryName(name) {
+function getBundledBinaryName(name) {
+    if (name === 'ripgrep') {
+        name = 'rg';
+    }
     if (process.platform == 'win32') {
         if (['npm', 'npx'].includes(name)) {
             return name;
@@ -141,7 +178,7 @@ function getBinaryName(name) {
  * @param name Binary Name
  * @returns Whether the binary exists
  */
-function isBinaryExists(name) {
+function isBundledBinaryExists(name) {
     const cmd = getBundledBinaryPath(name);
     return Bun.file(cmd).size > 0;
 }
@@ -155,7 +192,7 @@ function getBundledBinaryPath(name) {
     if (!name) {
         return binariesDir;
     }
-    const binaryName = getBinaryName(name);
+    const binaryName = getBundledBinaryName(name);
     const binariesDirExists = fs_1.default.existsSync(binariesDir);
     if (binariesDirExists) {
         if (['git', 'bash', 'sh'].includes(name)) {
@@ -166,28 +203,32 @@ function getBundledBinaryPath(name) {
             // Node.js binaries are in a subdirectory
             return path_1.default.join(binariesDir, 'node', binaryName);
         }
-        if (['python', 'python3'].includes(name)) {
+        if (['python'].includes(name)) {
             // Python binaries are in a subdirectory
             return path_1.default.join(binariesDir, 'python', binaryName);
         }
         if (['pip', 'pip3'].includes(name)) {
-            // pip binaries are in a subdirectory
+            // Python binaries are in a subdirectory
             return path_1.default.join(binariesDir, 'python/Scripts', binaryName);
         }
+        if (['rg', 'ripgrep'].includes(name)) {
+            // ripgrep binaries are in a subdirectory
+            return path_1.default.join(binariesDir, 'ripgrep', binaryName);
+        }
         return path_1.default.join(binariesDir, binaryName);
     }
     return binaryName;
 }
-function getBinaryEnvs() {
+function getBundledBinaryEnvs() {
     const binariesDir = getBundledBinaryPath();
-    const envPaths = process.env?.path?.split(';') || [];
+    const envPaths = process.env?.PATH?.split(';') || [];
     envPaths.unshift(binariesDir); // bun uv uvx
     envPaths.unshift(path_1.default.join(binariesDir, 'node')); // node
     envPaths.unshift(path_1.default.join(binariesDir, 'python')); // python
     envPaths.unshift(path_1.default.join(binariesDir, 'python/Scripts')); // pip
     const nodePath = getBundledBinaryPath('node');
     const nodeDir = path_1.default.join(nodePath, '..');
-    return {
+    const envs = {
         PATH: envPaths.join(';'),
         NODE: nodePath,
         npm_config_globalconfig: path_1.default.join(nodeDir, 'etc', 'npmrc'),
@@ -195,4 +236,20 @@ function getBinaryEnvs() {
         npm_config_prefix: nodeDir,
         npm_node_execpath: nodePath
     };
+    const MORE_ENV_VARS = [
+        'BUN_TMPDIR',
+        'BUN_INSTALL',
+        'NPM_CONFIG_REGISTRY',
+        'UV_PYTHON_INSTALL_MIRROR',
+        'UV_DEFAULT_INDEX',
+        'PIP_INDEX_URL'
+    ];
+    for (const key of MORE_ENV_VARS) {
+        const value = process.env[key];
+        if (value === undefined) {
+            continue;
+        }
+        envs[key] = value;
+    }
+    return envs;
 }

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/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.1",
+  "version": "0.0.3",
   "main": "./dist/index.js",
   "files": [
     "dist",

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;
-}