@hanhnd/agent-kit 1.0.38 → 1.0.40

package/dist/utils/async.d.ts

@@ -1 +1,2 @@
 export declare function withTimeout<T>(promise: Promise<T>, timeoutMs: number, createError: () => Error): Promise<T>;
+export declare function mapLimit<T, R>(items: readonly T[], limit: number, worker: (item: T, index: number) => Promise<R>): Promise<R[]>;

package/dist/utils/async.js

@@ -13,3 +13,20 @@ export async function withTimeout(promise, timeoutMs, createError) {
             clearTimeout(timer);
     }
 }
+export async function mapLimit(items, limit, worker) {
+    if (items.length === 0)
+        return [];
+    const concurrency = Math.max(1, Math.floor(limit));
+    const results = new Array(items.length);
+    let nextIndex = 0;
+    async function runWorker() {
+        while (nextIndex < items.length) {
+            const currentIndex = nextIndex;
+            nextIndex++;
+            results[currentIndex] = await worker(items[currentIndex], currentIndex);
+        }
+    }
+    const runners = Array.from({ length: Math.min(concurrency, items.length) }, () => runWorker());
+    await Promise.all(runners);
+    return results;
+}

package/dist/utils/async.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/utils/async.test.js

@@ -0,0 +1,48 @@
+import * as assert from 'node:assert/strict';
+import { describe, test } from 'node:test';
+import { mapLimit } from './async.js';
+describe('mapLimit', () => {
+    test('returns an empty array for empty input', async () => {
+        const results = await mapLimit([], 3, async (item) => item);
+        assert.deepEqual(results, []);
+    });
+    test('preserves result order while workers resolve out of order', async () => {
+        const results = await mapLimit([30, 10, 20], 3, async (delayMs, index) => {
+            await new Promise((resolve) => setTimeout(resolve, delayMs));
+            return index;
+        });
+        assert.deepEqual(results, [0, 1, 2]);
+    });
+    test('caps active workers at the configured limit', async () => {
+        let active = 0;
+        let maxActive = 0;
+        await mapLimit([1, 2, 3, 4, 5], 2, async (item) => {
+            active++;
+            maxActive = Math.max(maxActive, active);
+            await new Promise((resolve) => setTimeout(resolve, 5));
+            active--;
+            return item;
+        });
+        assert.equal(maxActive, 2);
+    });
+    test('clamps invalid limits to one worker', async () => {
+        let active = 0;
+        let maxActive = 0;
+        await mapLimit([1, 2, 3], 0, async (item) => {
+            active++;
+            maxActive = Math.max(maxActive, active);
+            await new Promise((resolve) => setTimeout(resolve, 5));
+            active--;
+            return item;
+        });
+        assert.equal(maxActive, 1);
+    });
+    test('rejects with the original worker error', async () => {
+        const expected = new Error('worker failed');
+        await assert.rejects(mapLimit([1, 2], 2, async (item) => {
+            if (item === 2)
+                throw expected;
+            return item;
+        }), expected);
+    });
+});

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@hanhnd/agent-kit",
-  "version": "1.0.38",
+  "version": "1.0.40",
   "description": "Agent Kit MCP server for software development agent workflows",
   "type": "module",
   "main": "dist/server.js",