@lousy-agents/mcp 5.21.3 → 5.21.4

package/dist/475.js

@@ -41,7 +41,9 @@ const defaultOptions = {
     lstat: false,
     depth: 2147483648,
     alwaysStat: false,
-    highWaterMark: 4096,
+    // Throughput is flat from 16 to 65536 (traversal is I/O-bound), but
+    // batches of 1024+ entries survive young-gen GC and bloat RSS ~20-60%.
+    highWaterMark: 256,
 };
 Object.freeze(defaultOptions);
 const RECURSIVE_ERROR_CODE = 'READDIRP_RECURSIVE_ERROR';
@@ -80,8 +82,12 @@ const normalizeFilter = (filter) => {
     }
     return emptyFn;
 };
-/** Readable readdir stream, emitting new files as they're being listed. */
 class ReaddirpStream extends external_node_stream_.Readable {
+    /**
+     * Directories discovered but not yet emitted from. Listings are read
+     * lazily (on pop, plus one prefetch) instead of eagerly on discovery:
+     * keeping whole listings for every queued dir balloons RAM on wide trees.
+     */
     parents;
     reading;
     parent;
@@ -96,14 +102,17 @@ class ReaddirpStream extends external_node_stream_.Readable {
     _rdOptions;
     _fileFilter;
     _directoryFilter;
+    _relStart;
     constructor(options = {}) {
         super({
             objectMode: true,
             autoDestroy: true,
-            highWaterMark: options.highWaterMark,
+            highWaterMark: options.highWaterMark ?? defaultOptions.highWaterMark,
         });
         const opts = { ...defaultOptions, ...options };
-        const { root, type } = opts;
+        // Use ?? so an explicit `undefined` in user options doesn't shadow defaults.
+        const root = opts.root ?? defaultOptions.root;
+        const type = opts.type ?? defaultOptions.type;
         this._fileFilter = normalizeFilter(opts.fileFilter);
         this._directoryFilter = normalizeFilter(opts.directoryFilter);
         const statMethod = opts.lstat ? promises_.lstat : promises_.stat;
@@ -116,15 +125,23 @@ class ReaddirpStream extends external_node_stream_.Readable {
         }
         this._maxDepth =
             opts.depth != null && Number.isSafeInteger(opts.depth) ? opts.depth : defaultOptions.depth;
-        this._wantsDir = type ? DIR_TYPES.has(type) : false;
-        this._wantsFile = type ? FILE_TYPES.has(type) : false;
+        this._wantsDir = DIR_TYPES.has(type);
+        this._wantsFile = FILE_TYPES.has(type);
         this._wantsEverything = type === EntryTypes.EVERYTHING_TYPE;
         this._root = (0,external_node_path_.resolve)(root);
+        // Every fullPath is `_root + sep + relative path` (see _formatEntry), so
+        // the relative path is a slice starting past the root and its trailing
+        // separator (which resolved paths lack, except fs roots like '/', 'C:\').
+        this._relStart = this._root.endsWith(external_node_path_.sep) ? this._root.length : this._root.length + 1;
         this._isDirent = !opts.alwaysStat;
         this._statsProp = this._isDirent ? 'dirent' : 'stats';
         this._rdOptions = { encoding: 'utf8', withFileTypes: this._isDirent };
-        // Launch stream with one parent, the root dir.
-        this.parents = [this._exploreDir(root, 1)];
+        // Launch stream with one parent, the root dir, whose readdir starts
+        // right away. Explore the resolved root so all parent paths stay
+        // absolute even if process.cwd() changes mid-iteration.
+        const rootDir = { path: this._root, depth: 1 };
+        rootDir.pending = this._exploreDir(this._root, 1);
+        this.parents = [rootDir];
         this.reading = false;
         this.parent = undefined;
     }
@@ -139,16 +156,25 @@ class ReaddirpStream extends external_node_stream_.Readable {
                 if (fil && fil.length > 0) {
                     const { path, depth } = par;
                     const slice = fil.splice(0, batch).map((dirent) => this._formatEntry(dirent, path));
-                    const awaited = await Promise.all(slice);
+                    // In dirent mode _formatEntry is synchronous: skip Promise.all and
+                    // its per-entry microtask overhead.
+                    const awaited = this._isDirent
+                        ? slice
+                        : await Promise.all(slice);
                     for (const entry of awaited) {
                         if (!entry)
                             continue;
                         if (this.destroyed)
                             return;
-                        const entryType = await this._getEntryType(entry);
+                        // Only symlinks require async work; plain files / dirs resolve synchronously.
+                        let entryType = this._getEntryType(entry);
+                        if (typeof entryType !== 'string')
+                            entryType = await entryType;
                         if (entryType === 'directory' && this._directoryFilter(entry)) {
                             if (depth <= this._maxDepth) {
-                                this.parents.push(this._exploreDir(entry.fullPath, depth + 1));
+                                // Lazy: don't readdir until this dir is popped. Keeping whole
+                                // listings for every queued dir would balloon RAM on wide trees.
+                                this.parents.push({ path: entry.fullPath, depth: depth + 1 });
                             }
                             if (this._wantsDir) {
                                 this.push(entry);
@@ -170,7 +196,15 @@ class ReaddirpStream extends external_node_stream_.Readable {
                         this.push(null);
                         break;
                     }
-                    this.parent = await parent;
+                    const dir = parent.pending ?? this._exploreDir(parent.path, parent.depth);
+                    // Prefetch the next dir so its readdir overlaps with processing
+                    // this one's entries. Only the stack top is prefetched, keeping at
+                    // most a handful of listings (~tree depth) in RAM at once.
+                    const next = this.parents[this.parents.length - 1];
+                    if (next && !next.pending) {
+                        next.pending = this._exploreDir(next.path, next.depth);
+                    }
+                    this.parent = await dir;
                     if (this.destroyed)
                         return;
                 }
@@ -183,6 +217,18 @@ class ReaddirpStream extends external_node_stream_.Readable {
             this.reading = false;
         }
     }
+    // NOTE: native `readdir(path, { recursive: true })` was evaluated as a
+    // replacement for this per-directory traversal and rejected:
+    // - Not faster: node implements it in JS, walking directories sequentially
+    //   just like this loop, but with extra path bookkeeping. Benchmarks
+    //   (node 24): ~10% slower on wide trees, ~40% slower on small ones,
+    //   parity on deep ones.
+    // - Much more RAM: it buffers the entire subtree listing in one array,
+    //   instead of one directory at a time, defeating streaming.
+    // - Semantics diverge: it can't limit depth, can't skip directories a
+    //   directoryFilter rejects, doesn't follow symlinked dirs, and fails
+    //   wholesale (all entries lost) if anything in the subtree is unreadable,
+    //   instead of emitting a 'warn' and continuing.
     async _exploreDir(path, depth) {
         let files;
         try {
@@ -193,19 +239,27 @@ class ReaddirpStream extends external_node_stream_.Readable {
         }
         return { files, depth, path };
     }
-    async _formatEntry(dirent, path) {
-        let entry;
+    // Synchronous in dirent mode; returns a promise only when stats are needed.
+    _formatEntry(dirent, path) {
         const basename = this._isDirent ? dirent.name : dirent;
-        try {
-            const fullPath = (0,external_node_path_.resolve)((0,external_node_path_.join)(path, basename));
-            entry = { path: (0,external_node_path_.relative)(this._root, fullPath), fullPath, basename };
-            entry[this._statsProp] = this._isDirent ? dirent : await this._stat(fullPath);
+        // `path` is always an absolute, normalized parent dir (see _exploreDir
+        // seeding in the constructor), so a plain join is enough — resolve()
+        // would re-read cwd on every entry.
+        const fullPath = (0,external_node_path_.join)(path, basename);
+        // Slice instead of path.relative(): equivalent here (fullPath is always
+        // under _root) and avoids several intermediate allocations per entry.
+        const entry = { path: fullPath.slice(this._relStart), fullPath, basename };
+        if (this._isDirent) {
+            entry.dirent = dirent;
+            return entry;
         }
-        catch (err) {
+        return this._stat(fullPath).then((stats) => {
+            entry.stats = stats;
+            return entry;
+        }, (err) => {
             this._onError(err);
-            return;
-        }
-        return entry;
+            return undefined;
+        });
     }
     _onError(err) {
         if (isNormalFlowError(err) && !this.destroyed) {
@@ -215,10 +269,12 @@ class ReaddirpStream extends external_node_stream_.Readable {
             this.destroy(err);
         }
     }
-    async _getEntryType(entry) {
+    // Synchronous for regular files and directories; returns a promise only for
+    // symlinks, which need realpath() to be classified.
+    _getEntryType(entry) {
         // entry may be undefined, because a warning or an error were emitted
         // and the statsProp is undefined
-        if (!entry && this._statsProp in entry) {
+        if (!entry || !(this._statsProp in entry)) {
             return '';
         }
         const stats = entry[this._statsProp];
@@ -226,30 +282,34 @@ class ReaddirpStream extends external_node_stream_.Readable {
             return 'file';
         if (stats.isDirectory())
             return 'directory';
-        if (stats && stats.isSymbolicLink()) {
-            const full = entry.fullPath;
-            try {
-                const entryRealPath = await (0,promises_.realpath)(full);
-                const entryRealPathStats = await (0,promises_.lstat)(entryRealPath);
-                if (entryRealPathStats.isFile()) {
-                    return 'file';
-                }
-                if (entryRealPathStats.isDirectory()) {
-                    const len = entryRealPath.length;
-                    if (full.startsWith(entryRealPath) && full.substr(len, 1) === external_node_path_.sep) {
-                        const recursiveError = new Error(`Circular symlink detected: "${full}" points to "${entryRealPath}"`);
-                        // @ts-ignore
-                        recursiveError.code = RECURSIVE_ERROR_CODE;
-                        return this._onError(recursiveError);
-                    }
-                    return 'directory';
-                }
+        if (stats.isSymbolicLink())
+            return this._getSymlinkEntryType(entry);
+        return '';
+    }
+    async _getSymlinkEntryType(entry) {
+        const full = entry.fullPath;
+        try {
+            const entryRealPath = await (0,promises_.realpath)(full);
+            const entryRealPathStats = await (0,promises_.lstat)(entryRealPath);
+            if (entryRealPathStats.isFile()) {
+                return 'file';
             }
-            catch (error) {
-                this._onError(error);
-                return '';
+            if (entryRealPathStats.isDirectory()) {
+                const len = entryRealPath.length;
+                if (full.startsWith(entryRealPath) && full[len] === external_node_path_.sep) {
+                    const recursiveError = new Error(`Circular symlink detected: "${full}" points to "${entryRealPath}"`);
+                    // @ts-ignore
+                    recursiveError.code = RECURSIVE_ERROR_CODE;
+                    this._onError(recursiveError);
+                    return '';
+                }
+                return 'directory';
             }
         }
+        catch (error) {
+            this._onError(error);
+        }
+        return '';
     }
     _includeAsFile(entry) {
         const stats = entry && entry[this._statsProp];
@@ -267,8 +327,6 @@ function readdirp(root, options = {}) {
     let type = options.entryType || options.type;
     if (type === 'both')
         type = EntryTypes.FILE_DIR_TYPE; // backwards-compatibility
-    if (type)
-        options.type = type;
     if (!root) {
         throw new Error('readdirp: root argument is required. Usage: readdirp(root, options)');
     }
@@ -278,8 +336,11 @@ function readdirp(root, options = {}) {
     else if (type && !ALL_TYPES.includes(type)) {
         throw new Error(`readdirp: Invalid type passed. Use one of ${ALL_TYPES.join(', ')}`);
     }
-    options.root = root;
-    return new ReaddirpStream(options);
+    // Copy options instead of mutating the caller's object.
+    const opts = { ...options, root };
+    if (type)
+        opts.type = type;
+    return new ReaddirpStream(opts);
 }
 /**
  * Promise version: Reads all files and directories in given root recursively.

package/dist/61.js

@@ -0,0 +1,281 @@
+export const __rspack_esm_id = 61;
+export const __rspack_esm_ids = [61];
+export const __webpack_modules__ = {
+2244(__unused_rspack___webpack_module__, __webpack_exports__, __webpack_require__) {
+
+// EXPORTS
+__webpack_require__.d(__webpack_exports__, {
+  diff: () => (/* binding */ diff)
+});
+
+// UNUSED EXPORTS: isEqual
+
+;// CONCATENATED MODULE: ../../node_modules/ohash/dist/_chunks/is-equal.mjs
+function serialize(input) {
+	if (typeof input === "string") return `'${input}'`;
+	return new is_equal_Serializer().serialize(input);
+}
+const asciiOrder = " _-,;:!?.'\"()[]{}@*/\\&#%`^+<=>|~$0123456789abcdefghijklmnopqrstuvwxyz";
+const asciiWeights = /*@__PURE__*/ (function() {
+	const weights = /* @__PURE__ */ new Uint8Array(128);
+	for (let i = 0; i < 69; i++) weights[asciiOrder.charCodeAt(i)] = i + 1;
+	for (let code = 65; code <= 90; code++) weights[code] = weights[code + 32];
+	return weights;
+})();
+function compareStrings(a, b) {
+	if (a === b) return 0;
+	const length = Math.min(a.length, b.length);
+	let tieBreaker = 0;
+	for (let i = 0; i < length; i++) {
+		const codeA = a.charCodeAt(i);
+		const codeB = b.charCodeAt(i);
+		if (codeA === codeB) continue;
+		const weightA = codeA < 128 && asciiWeights[codeA] ? asciiWeights[codeA] : codeA + 128;
+		const weightB = codeB < 128 && asciiWeights[codeB] ? asciiWeights[codeB] : codeB + 128;
+		if (weightA !== weightB) return weightA < weightB ? -1 : 1;
+		if (tieBreaker === 0) tieBreaker = codeA > codeB ? -1 : 1;
+	}
+	if (a.length !== b.length) return a.length < b.length ? -1 : 1;
+	return tieBreaker;
+}
+const is_equal_Serializer = /*@__PURE__*/ (function() {
+	class Serializer {
+		#context = /* @__PURE__ */ new Map();
+		compare(a, b) {
+			const typeA = typeof a;
+			const typeB = typeof b;
+			if (typeA === "string" && typeB === "string") return compareStrings(a, b);
+			if (typeA === "number" && typeB === "number") return a - b;
+			return compareStrings(this.serialize(a, true), this.serialize(b, true));
+		}
+		serialize(value, noQuotes) {
+			if (value === null) return "null";
+			switch (typeof value) {
+				case "string": return noQuotes ? value : `'${value}'`;
+				case "bigint": return `${value}n`;
+				case "object": return this.$object(value);
+				case "function": return this.$function(value);
+			}
+			return String(value);
+		}
+		serializeObject(object) {
+			const objString = Object.prototype.toString.call(object);
+			if (objString !== "[object Object]") return this.serializeBuiltInType(objString.length < 10 ? `unknown:${objString}` : objString.slice(8, -1), object);
+			const constructor = object.constructor;
+			const objName = constructor === Object || constructor === void 0 ? "" : constructor.name;
+			if (objName !== "" && globalThis[objName] === constructor) return this.serializeBuiltInType(objName, object);
+			if ("toJSON" in object && typeof object.toJSON === "function") {
+				const json = object.toJSON();
+				return objName + (json !== null && typeof json === "object" ? this.$object(json) : `(${this.serialize(json)})`);
+			}
+			const keys = Object.keys(object).sort(compareStrings);
+			let content = `${objName}{`;
+			for (let i = 0; i < keys.length; i++) {
+				const key = keys[i];
+				content += `${key}:${this.serialize(object[key])}`;
+				if (i < keys.length - 1) content += ",";
+			}
+			return content + "}";
+		}
+		serializeBuiltInType(type, object) {
+			const handler = this["$" + type];
+			if (handler) return handler.call(this, object);
+			if (typeof object.entries === "function") return this.serializeObjectEntries(type, object.entries());
+			throw new Error(`Cannot serialize ${type}`);
+		}
+		serializeObjectEntries(type, entries) {
+			const sortedEntries = Array.from(entries).sort((a, b) => this.compare(a[0], b[0]));
+			let content = `${type}{`;
+			for (let i = 0; i < sortedEntries.length; i++) {
+				const [key, value] = sortedEntries[i];
+				content += `${this.serialize(key, true)}:${this.serialize(value)}`;
+				if (i < sortedEntries.length - 1) content += ",";
+			}
+			return content + "}";
+		}
+		$object(object) {
+			let content = this.#context.get(object);
+			if (content === void 0) {
+				this.#context.set(object, `#${this.#context.size}`);
+				content = this.serializeObject(object);
+				this.#context.set(object, content);
+			}
+			return content;
+		}
+		$function(fn) {
+			const fnStr = Function.prototype.toString.call(fn);
+			if (fnStr.slice(-15) === "[native code] }") return `${fn.name || ""}()[native]`;
+			return `${fn.name}(${fn.length})${fnStr.replace(/\s*\n\s*/g, "")}`;
+		}
+		$Array(arr) {
+			let content = "[";
+			for (let i = 0; i < arr.length; i++) {
+				content += this.serialize(arr[i]);
+				if (i < arr.length - 1) content += ",";
+			}
+			return content + "]";
+		}
+		$Date(date) {
+			try {
+				return `Date(${date.toISOString()})`;
+			} catch {
+				return `Date(null)`;
+			}
+		}
+		$ArrayBuffer(arr) {
+			return `ArrayBuffer[${new Uint8Array(arr).join(",")}]`;
+		}
+		$Set(set) {
+			return `Set${this.$Array(Array.from(set).sort((a, b) => this.compare(a, b)))}`;
+		}
+		$Map(map) {
+			return this.serializeObjectEntries("Map", map.entries());
+		}
+	}
+	for (const type of [
+		"Error",
+		"RegExp",
+		"URL"
+	]) Serializer.prototype["$" + type] = function(val) {
+		return `${type}(${val})`;
+	};
+	for (const type of [
+		"Int8Array",
+		"Uint8Array",
+		"Uint8ClampedArray",
+		"Int16Array",
+		"Uint16Array",
+		"Int32Array",
+		"Uint32Array",
+		"Float32Array",
+		"Float64Array"
+	]) Serializer.prototype["$" + type] = function(arr) {
+		return `${type}[${arr.join(",")}]`;
+	};
+	for (const type of ["BigInt64Array", "BigUint64Array"]) Serializer.prototype["$" + type] = function(arr) {
+		return `${type}[${arr.join("n,")}${arr.length > 0 ? "n" : ""}]`;
+	};
+	return Serializer;
+})();
+function isEqual(object1, object2) {
+	if (object1 === object2) return true;
+	if (serialize(object1) === serialize(object2)) return true;
+	return false;
+}
+
+
+;// CONCATENATED MODULE: ../../node_modules/ohash/dist/utils/index.mjs
+
+const PROTO_KEY = "__proto__";
+function diff(obj1, obj2) {
+	const diffs = [];
+	_diff(obj1, obj2, "", diffs);
+	return diffs;
+}
+function _diff(v1, v2, key, out) {
+	if (v1 === v2) return;
+	const leaf1 = v1 === null || typeof v1 !== "object";
+	const leaf2 = v2 === null || typeof v2 !== "object";
+	if (!leaf1 && !leaf2) {
+		const entries1 = _entries(v1);
+		const entries2 = _entries(v2);
+		for (const [k, child1] of entries1) {
+			const childKey = key ? `${key}.${k}` : k;
+			if (entries2.has(k)) _diff(child1, entries2.get(k), childKey, out);
+			else out.push(new DiffEntry(childKey, "removed", void 0, _toHashedObject(child1, childKey)));
+		}
+		for (const [k, child2] of entries2) {
+			if (entries1.has(k)) continue;
+			const childKey = key ? `${key}.${k}` : k;
+			out.push(new DiffEntry(childKey, "added", _toHashedObject(child2, childKey)));
+		}
+		return;
+	}
+	if (_hasKeys(v1, leaf1) || _hasKeys(v2, leaf2)) return;
+	const node1 = _emptyOrLeafNode(v1, key, leaf1);
+	const node2 = _emptyOrLeafNode(v2, key, leaf2);
+	if (node1.hash !== node2.hash) out.push(new DiffEntry(key, "changed", node2, node1));
+}
+function _entries(value) {
+	const entries = /* @__PURE__ */ new Map();
+	for (const key in value) if (key !== PROTO_KEY) entries.set(key, value[key]);
+	return entries;
+}
+function _hasKeys(value, isLeaf) {
+	if (isLeaf) return false;
+	for (const key in value) if (key !== PROTO_KEY) return true;
+	return false;
+}
+function _emptyOrLeafNode(value, key, isLeaf) {
+	return isLeaf ? new DiffHashedObject(key, value, _leafHash(value)) : new DiffHashedObject(key, value, "{}", Object.create(null));
+}
+function _toHashedObject(obj, key = "") {
+	if (obj === null || typeof obj !== "object") return new DiffHashedObject(key, obj, _leafHash(obj));
+	const props = Object.create(null);
+	const hashes = [];
+	for (const _key in obj) {
+		if (_key === PROTO_KEY) continue;
+		const child = _toHashedObject(obj[_key], key ? `${key}.${_key}` : _key);
+		props[_key] = child;
+		hashes.push(child.hash);
+	}
+	return new DiffHashedObject(key, obj, `{${hashes.join(":")}}`, props);
+}
+function _leafHash(value) {
+	switch (typeof value) {
+		case "string": return `'${value}'`;
+		case "number":
+		case "boolean": return "" + value;
+		case "bigint": return `${value}n`;
+		default: return serialize(value);
+	}
+}
+var DiffEntry = class {
+	key;
+	type;
+	newValue;
+	oldValue;
+	constructor(key, type, newValue, oldValue) {
+		this.key = key;
+		this.type = type;
+		this.newValue = newValue;
+		this.oldValue = oldValue;
+	}
+	toString() {
+		return this.toJSON();
+	}
+	toJSON() {
+		switch (this.type) {
+			case "added": return `Added   \`${this.key}\``;
+			case "removed": return `Removed \`${this.key}\``;
+			case "changed": return `Changed \`${this.key}\` from \`${this.oldValue?.toString() || "-"}\` to \`${this.newValue?.toString()}\``;
+		}
+	}
+};
+var DiffHashedObject = class {
+	key;
+	value;
+	hash;
+	props;
+	constructor(key, value, hash, props) {
+		this.key = key;
+		this.value = value;
+		this.hash = hash;
+		this.props = props;
+	}
+	toString() {
+		if (this.props) return `{${Object.keys(this.props).join(",")}}`;
+		else return JSON.stringify(this.value);
+	}
+	toJSON() {
+		const k = this.key || ".";
+		if (this.props) return `${k}({${Object.keys(this.props).join(",")}})`;
+		return `${k}(${this.value})`;
+	}
+};
+
+
+
+},
+
+};

package/dist/962.js

@@ -5,7 +5,7 @@ export const __webpack_modules__ = {
 
 // EXPORTS
 __webpack_require__.d(__webpack_exports__, {
-  digest: () => (/* reexport */ node_digest)
+  digest: () => (/* reexport */ digest)
 });
 
 // UNUSED EXPORTS: hash, isEqual, serialize
@@ -14,24 +14,25 @@ __webpack_require__.d(__webpack_exports__, {
 var external_node_crypto_ = __webpack_require__(7598);
 ;// CONCATENATED MODULE: ../../node_modules/ohash/dist/crypto/node/index.mjs
 
-
-const e=globalThis.process?.getBuiltinModule?.("crypto")?.hash,r="sha256",s="base64url";function node_digest(t){if(e)return e(r,t,s);const o=(0,external_node_crypto_.createHash)(r).update(t);return globalThis.process?.versions?.webcontainer?o.digest().toString(s):o.digest(s)}
-
+const fastHash = /*@__PURE__*/ (() => globalThis.process?.getBuiltinModule?.("crypto")?.hash)();
+const algorithm = "sha256";
+const encoding = "base64url";
+function digest(data) {
+	if (fastHash) return fastHash(algorithm, data, encoding);
+	const h = (0,external_node_crypto_.createHash)(algorithm).update(data);
+	return globalThis.process?.versions?.webcontainer ? h.digest().toString(encoding) : h.digest(encoding);
+}
 
 
 ;// CONCATENATED MODULE: ../../node_modules/ohash/dist/index.mjs
 
 
-
-
-
 function hash(input) {
-  return digest(serialize(input));
+	return digest$1(serialize(input));
 }
 
 
 
-
 },
 
 };