bimp-mcp 0.2.0

package/dist/utilities.js

@@ -0,0 +1,270 @@
+const PAGE_SIZE = 100;
+/**
+ * Derive the "read" tool name from a "readList" tool name.
+ * bimp_foo_readList       -> bimp_foo_read
+ * bimp_foo_readList_cursor -> bimp_foo_read
+ */
+function deriveReadToolName(listToolName) {
+    return listToolName.replace(/_readList(?:_cursor)?$/, "_read");
+}
+/**
+ * Run promises in batches of `concurrency`, collecting all settled results.
+ */
+async function runInBatches(tasks, concurrency) {
+    const results = [];
+    for (let i = 0; i < tasks.length; i += concurrency) {
+        const batch = tasks.slice(i, i + concurrency);
+        const settled = await Promise.allSettled(batch.map((fn) => fn()));
+        results.push(...settled);
+    }
+    return results;
+}
+/**
+ * Internal batch-read logic shared by bimp_fetch_all (enrich) and bimp_batch_read.
+ */
+async function batchReadUuids(client, toolDef, uuids, concurrency) {
+    const items = [];
+    const errors = [];
+    const tasks = uuids.map((uuid) => async () => {
+        const response = (await client.request(toolDef.metadata.method, toolDef.metadata.path, { uuid }));
+        return { uuid, data: response.data };
+    });
+    const results = await runInBatches(tasks, concurrency);
+    for (let i = 0; i < results.length; i++) {
+        const result = results[i];
+        if (result.status === "fulfilled") {
+            items.push(result.value.data);
+        }
+        else {
+            errors.push({
+                uuid: uuids[i],
+                error: result.reason instanceof Error ? result.reason.message : String(result.reason),
+            });
+        }
+    }
+    return { items, errors };
+}
+function createFetchAllTool(client, toolMap) {
+    return {
+        name: "bimp_fetch_all",
+        description: "Auto-paginate any readList endpoint to fetch all items. " +
+            "Supports offset, cursor, page, and none pagination types. " +
+            "Use enrich=true to call the corresponding read endpoint for full details on each item.",
+        inputSchema: {
+            type: "object",
+            properties: {
+                tool: {
+                    type: "string",
+                    description: "Name of a readList tool to paginate (e.g. bimp_nomenclature_readList)",
+                },
+                limit: {
+                    type: "number",
+                    description: "Maximum number of items to return (default: unlimited)",
+                },
+                enrich: {
+                    type: "boolean",
+                    description: "If true, fetch full details for each item via the corresponding read endpoint",
+                },
+                filters: {
+                    type: "object",
+                    description: "Additional filter parameters to pass through to the API",
+                },
+            },
+            required: ["tool"],
+        },
+        handler: async (params) => {
+            const toolName = params.tool;
+            const limit = params.limit;
+            const enrich = params.enrich;
+            const filters = (params.filters ?? {});
+            const toolDef = toolMap.get(toolName);
+            if (!toolDef) {
+                throw new Error(`Tool not found: ${toolName}`);
+            }
+            let allItems = [];
+            const paginationType = toolDef.metadata.paginationType;
+            if (paginationType === "offset") {
+                let offset = 0;
+                while (true) {
+                    const requestParams = {
+                        ...filters,
+                        pagination: { offset, count: PAGE_SIZE },
+                    };
+                    const response = (await client.request(toolDef.metadata.method, toolDef.metadata.path, requestParams));
+                    const page = response.data ?? [];
+                    allItems.push(...page);
+                    if (limit && allItems.length >= limit) {
+                        allItems = allItems.slice(0, limit);
+                        break;
+                    }
+                    if (page.length < PAGE_SIZE) {
+                        break;
+                    }
+                    offset += PAGE_SIZE;
+                }
+            }
+            else if (paginationType === "cursor") {
+                let cursor;
+                while (true) {
+                    const requestParams = {
+                        ...filters,
+                        ...(cursor ? { cursor } : {}),
+                        count: PAGE_SIZE,
+                    };
+                    const response = (await client.request(toolDef.metadata.method, toolDef.metadata.path, requestParams));
+                    const page = response.data ?? [];
+                    allItems.push(...page);
+                    if (limit && allItems.length >= limit) {
+                        allItems = allItems.slice(0, limit);
+                        break;
+                    }
+                    cursor = response.cursor;
+                    if (!cursor || page.length < PAGE_SIZE) {
+                        break;
+                    }
+                }
+            }
+            else if (paginationType === "page") {
+                let page = 1;
+                while (true) {
+                    const requestParams = {
+                        ...filters,
+                        page,
+                        pageSize: PAGE_SIZE,
+                    };
+                    const response = (await client.request(toolDef.metadata.method, toolDef.metadata.path, requestParams));
+                    const items = response.data ?? [];
+                    allItems.push(...items);
+                    if (limit && allItems.length >= limit) {
+                        allItems = allItems.slice(0, limit);
+                        break;
+                    }
+                    if (items.length < PAGE_SIZE) {
+                        break;
+                    }
+                    page++;
+                }
+            }
+            else {
+                // paginationType === "none" — single request
+                const requestParams = { ...filters };
+                const response = (await client.request(toolDef.metadata.method, toolDef.metadata.path, requestParams));
+                const items = response.data ?? [];
+                allItems.push(...items);
+                if (limit && allItems.length > limit) {
+                    allItems = allItems.slice(0, limit);
+                }
+            }
+            // Enrich: call the read endpoint for each item
+            if (enrich && allItems.length > 0) {
+                const readToolName = deriveReadToolName(toolName);
+                const readToolDef = toolMap.get(readToolName);
+                if (!readToolDef) {
+                    throw new Error(`Cannot enrich: read tool not found (expected ${readToolName})`);
+                }
+                const uuids = allItems
+                    .map((item) => item.uuid)
+                    .filter(Boolean);
+                const { items: enrichedItems } = await batchReadUuids(client, readToolDef, uuids, 10);
+                return { items: enrichedItems, count: enrichedItems.length };
+            }
+            return { items: allItems, count: allItems.length };
+        },
+    };
+}
+function createBatchReadTool(client, toolMap) {
+    return {
+        name: "bimp_batch_read",
+        description: "Read multiple items by UUID in parallel. Provide the read tool name and an array of UUIDs.",
+        inputSchema: {
+            type: "object",
+            properties: {
+                tool: {
+                    type: "string",
+                    description: "Name of a read tool (e.g. bimp_nomenclature_read)",
+                },
+                uuids: {
+                    type: "array",
+                    items: { type: "string" },
+                    description: "Array of UUIDs to read",
+                },
+                concurrency: {
+                    type: "number",
+                    description: "Number of parallel requests (default: 10)",
+                },
+            },
+            required: ["tool", "uuids"],
+        },
+        handler: async (params) => {
+            const toolName = params.tool;
+            const uuids = params.uuids;
+            const concurrency = params.concurrency ?? 10;
+            const toolDef = toolMap.get(toolName);
+            if (!toolDef) {
+                throw new Error(`Tool not found: ${toolName}`);
+            }
+            return batchReadUuids(client, toolDef, uuids, concurrency);
+        },
+    };
+}
+function createBulkUpdateTool(client, toolMap) {
+    return {
+        name: "bimp_bulk_update",
+        description: "Update multiple items in parallel. Provide the update tool name and an array of items (each must include uuid).",
+        inputSchema: {
+            type: "object",
+            properties: {
+                tool: {
+                    type: "string",
+                    description: "Name of an update tool (e.g. bimp_nomenclature_update)",
+                },
+                items: {
+                    type: "array",
+                    items: { type: "object" },
+                    description: "Array of objects to update (each must contain uuid)",
+                },
+                concurrency: {
+                    type: "number",
+                    description: "Number of parallel requests (default: 5)",
+                },
+            },
+            required: ["tool", "items"],
+        },
+        handler: async (params) => {
+            const toolName = params.tool;
+            const items = params.items;
+            const concurrency = params.concurrency ?? 5;
+            const toolDef = toolMap.get(toolName);
+            if (!toolDef) {
+                throw new Error(`Tool not found: ${toolName}`);
+            }
+            let updated = 0;
+            const errors = [];
+            const tasks = items.map((item) => async () => {
+                await client.request(toolDef.metadata.method, toolDef.metadata.path, item);
+                return item.uuid;
+            });
+            const results = await runInBatches(tasks, concurrency);
+            for (let i = 0; i < results.length; i++) {
+                const result = results[i];
+                if (result.status === "fulfilled") {
+                    updated++;
+                }
+                else {
+                    errors.push({
+                        uuid: items[i].uuid ?? `item[${i}]`,
+                        error: result.reason instanceof Error ? result.reason.message : String(result.reason),
+                    });
+                }
+            }
+            return { updated, errors };
+        },
+    };
+}
+export function createUtilityTools(client, toolMap) {
+    return [
+        createFetchAllTool(client, toolMap),
+        createBatchReadTool(client, toolMap),
+        createBulkUpdateTool(client, toolMap),
+    ];
+}

package/package.json

@@ -0,0 +1,51 @@
+{
+  "name": "bimp-mcp",
+  "version": "0.2.0",
+  "description": "MCP server for BIMP ERP API — ~140 tools dynamically generated from OpenAPI spec, plus planning/accounting fields and bulk operations",
+  "type": "module",
+  "main": "dist/index.js",
+  "bin": {
+    "bimp-mcp": "dist/index.js"
+  },
+  "files": [
+    "dist",
+    "bimp-api.json"
+  ],
+  "scripts": {
+    "start": "tsx src/index.ts",
+    "dev": "tsx watch src/index.ts",
+    "build": "tsc -p tsconfig.build.json",
+    "prepublishOnly": "npm run build",
+    "test": "vitest run --project unit",
+    "test:integration": "vitest run --project integration",
+    "test:functional": "vitest run --project functional",
+    "test:all": "vitest run",
+    "test:watch": "vitest --project unit",
+    "demo:nomenclatures": "tsx scripts/demo-nomenclatures.ts"
+  },
+  "keywords": [
+    "mcp",
+    "model-context-protocol",
+    "bimp",
+    "erp",
+    "bimpsoft",
+    "claude",
+    "ai-tools"
+  ],
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/dutchakdev/bimp-mcp.git"
+  },
+  "dependencies": {
+    "@modelcontextprotocol/sdk": "^1.12.0",
+    "zod": "^3.25.0"
+  },
+  "devDependencies": {
+    "@types/node": "^22.0.0",
+    "dotenv": "^16.5.0",
+    "tsx": "^4.19.0",
+    "typescript": "^5.8.0",
+    "vitest": "^3.2.0"
+  }
+}