@mcpc-tech/core 0.2.0-beta.10

package/package.json

@@ -0,0 +1,38 @@
+{
+  "name": "@mcpc-tech/core",
+  "version": "0.2.0-beta.10",
+  "homepage": "https://jsr.io/@mcpc/core",
+  "type": "module",
+  "exports": {
+    "./types/*": "./types/*",
+    ".": {
+      "import": "./mod.mjs",
+      "types": "./types/mod.d.ts"
+    },
+    "./plugins": {
+      "import": "./plugins.mjs"
+    },
+    "./src/plugins/search-tool": {
+      "import": "./src/plugins/search-tool.mjs"
+    },
+    "./src/plugins/large-result": {
+      "import": "./src/plugins/large-result.mjs"
+    }
+  },
+  "dependencies": {
+    "jsonrepair": "^3.13.0",
+    "@modelcontextprotocol/sdk": "^1.8.0",
+    "ai": "^4.3.4",
+    "json-schema-traverse": "^1.0.0",
+    "cheerio": "^1.0.0",
+    "ajv": "^8.17.1",
+    "@segment/ajv-human-errors": "^2.15.0",
+    "ajv-formats": "^3.0.1",
+    "@mcpc-tech/ripgrep-napi": "^0.0.4"
+  },
+  "main": "./mod.mjs",
+  "types": "./types/mod.d.ts",
+  "scripts": {
+    "start": "node mod.mjs"
+  }
+}

package/plugins.mjs

@@ -0,0 +1,289 @@
+// ../__mcpc__core_0.2.0-beta.10/node_modules/@mcpc/core/src/plugins/search-tool.js
+import rg from "@mcpc-tech/ripgrep-napi";
+import { tmpdir } from "node:os";
+import { jsonSchema } from "ai";
+import { resolve } from "node:path";
+import { relative } from "node:path";
+function createSearchPlugin(options = {}) {
+  const maxResults = options.maxResults || 20;
+  const maxOutputSize = options.maxOutputSize || 5e3;
+  const allowedSearchDir = options.allowedDir || tmpdir();
+  const timeoutMs = options.timeoutMs || 3e4;
+  const global = options.global ?? true;
+  return {
+    name: "plugin-search",
+    configureServer: (server) => {
+      server.tool("search-tool-result", `Search for text patterns in files and directories. Use this to find specific content, code, or information within files. Provide a simple literal string or a regular expression. If your pattern is a regex, ensure it's valid; otherwise use quotes or escape special characters to treat it as a literal string.
+Only search within the allowed directory: ${allowedSearchDir}`, jsonSchema({
+        type: "object",
+        properties: {
+          pattern: {
+            type: "string",
+            description: "Text to search for. Can be a plain string or a regular expression. For regexes, don't include delimiters (e.g. use `^foo` not `/^foo/`). If you get a regex parse error, try escaping special chars or using a simpler literal search."
+          },
+          path: {
+            type: "string",
+            description: "File or folder path to limit the search (optional). Must be within the allowed directory."
+          },
+          maxResults: {
+            type: "number",
+            description: "Maximum number of matches to return (optional). Lower this to reduce output size and runtime."
+          }
+        },
+        required: [
+          "pattern"
+        ]
+      }), async (args) => {
+        const isBroad = (raw) => {
+          const t = (raw ?? "").trim();
+          if (!t) return true;
+          if (/^[*.\s]{2,}$/.test(t)) return true;
+          if (t === ".*" || t === "." || t === "^.*$") return true;
+          if (/^\^?\.\*\$?$/.test(t)) return true;
+          if (/^\\s?\*+$/.test(t)) return true;
+          return false;
+        };
+        const appendMatchSafely = (current, addition, limit) => {
+          if ((current + addition).length > limit) {
+            return {
+              current,
+              added: false
+            };
+          }
+          return {
+            current: current + addition,
+            added: true
+          };
+        };
+        try {
+          const requestedPath = args.path || allowedSearchDir;
+          const limit = args.maxResults || maxResults;
+          if (args.path) {
+            const resolvedRequested = resolve(args.path);
+            const resolvedAllowed = resolve(allowedSearchDir);
+            const relativePath = relative(resolvedAllowed, resolvedRequested);
+            if (relativePath && relativePath.startsWith("..")) {
+              return {
+                content: [
+                  {
+                    type: "text",
+                    text: `\u274C Path "${args.path}" not allowed. Must be within: ${allowedSearchDir}`
+                  }
+                ],
+                isError: true
+              };
+            }
+          }
+          const searchPath = requestedPath;
+          const rawPattern = args.pattern ?? "";
+          if (isBroad(rawPattern)) {
+            return {
+              content: [
+                {
+                  type: "text",
+                  text: `\u274C Search pattern too broad: "${rawPattern}"
+Provide a more specific pattern (e.g. include a filename fragment, a keyword, or limit with the "path" parameter). Avoid patterns that only contain wildcards like "*" or ".*".`
+                }
+              ],
+              isError: true
+            };
+          }
+          let timeoutId;
+          const timeoutPromise = new Promise((_, reject) => {
+            timeoutId = setTimeout(() => {
+              reject(new Error(`Search timeout after ${timeoutMs}ms`));
+            }, timeoutMs);
+          });
+          console.log(`Searching for "${args.pattern}" in ${searchPath}`);
+          const searchPromise = new Promise((resolve2, reject) => {
+            try {
+              const result2 = rg.search(args.pattern, [
+                searchPath
+              ]);
+              resolve2(result2);
+            } catch (error) {
+              reject(error);
+            }
+          });
+          const result = await Promise.race([
+            searchPromise,
+            timeoutPromise
+          ]);
+          if (timeoutId) clearTimeout(timeoutId);
+          if (!result.success || !result.matches?.length) {
+            return {
+              content: [
+                {
+                  type: "text",
+                  text: `No matches found for: "${args.pattern}"
+
+Try:
+- **Simpler pattern** or \`*\`
+- Check if files exist in: ${searchPath}
+- Use specific file path`
+                }
+              ]
+            };
+          }
+          const matches = result.matches.slice(0, limit);
+          let output = `Found ${result.matches.length} matches (showing up to ${matches.length}):
+
+`;
+          let matchesIncluded = 0;
+          for (const match of matches) {
+            const baseMatchText = `**${match.path}:${match.lineNumber}**
+`;
+            const fullMatchText = `${baseMatchText}\`\`\`
+${match.line}
+\`\`\`
+
+`;
+            const res = appendMatchSafely(output, fullMatchText, maxOutputSize);
+            if (!res.added) {
+              if (matchesIncluded === 0) {
+                const remainingSpace = maxOutputSize - output.length - 100;
+                if (remainingSpace > 50) {
+                  const truncatedLine = match.line.slice(0, remainingSpace);
+                  output += `${baseMatchText}\`\`\`
+${truncatedLine}...
+\`\`\`
+
+`;
+                  output += `\u26A0\uFE0F Content truncated
+`;
+                  matchesIncluded++;
+                } else {
+                  output += `\u26A0\uFE0F Content too large, use specific file path
+`;
+                }
+              }
+              break;
+            }
+            output = res.current;
+            matchesIncluded++;
+          }
+          if (matchesIncluded < matches.length) {
+            output += `
+\u26A0\uFE0F Showing ${matchesIncluded}/${matches.length} matches (size limit)
+`;
+            output += `
+For more results:
+`;
+            output += `- Use specific pattern: "${args.pattern} keyword"
+`;
+            output += `- Search specific file: {"pattern": "${args.pattern}", "path": "/file.txt"}
+`;
+            output += `- Use fewer results: {"maxResults": 5}`;
+          }
+          return {
+            content: [
+              {
+                type: "text",
+                text: output
+              }
+            ]
+          };
+        } catch (error) {
+          const errorMsg = error instanceof Error ? error.message : String(error);
+          const isTimeout = errorMsg.includes("timeout");
+          return {
+            content: [
+              {
+                type: "text",
+                text: `Search error: ${errorMsg}
+
+${isTimeout ? `Timeout after ${timeoutMs}ms. Try simpler pattern or smaller directory.` : `Check pattern syntax or directory exists.`}`
+              }
+            ]
+          };
+        }
+      }, {
+        internal: !global
+      });
+    }
+  };
+}
+var defaultSearchPlugin = createSearchPlugin({
+  global: true,
+  maxResults: 20,
+  maxOutputSize: 5e3,
+  caseSensitive: false,
+  timeoutMs: 3e4
+});
+var search_tool_default = defaultSearchPlugin;
+
+// ../__mcpc__core_0.2.0-beta.10/node_modules/@mcpc/core/src/plugins/large-result.js
+import { mkdtemp, writeFile } from "node:fs/promises";
+import { join } from "node:path";
+import { tmpdir as tmpdir2 } from "node:os";
+function createLargeResultPlugin(options = {}) {
+  const maxSize = options.maxSize || 8e3;
+  const previewSize = options.previewSize || 4e3;
+  let tempDir = options.tempDir || null;
+  const serversConfigured = /* @__PURE__ */ new WeakSet();
+  const searchConfig = {
+    maxResults: options.search?.maxResults || 15,
+    maxOutputSize: options.search?.maxOutputSize || 4e3,
+    global: true
+  };
+  return {
+    name: "plugin-large-result-handler",
+    configureServer: async (server) => {
+      if (!serversConfigured.has(server)) {
+        const searchPlugin = createSearchPlugin(searchConfig);
+        await server.addPlugin(searchPlugin);
+        serversConfigured.add(server);
+      }
+    },
+    transformTool: (tool, context) => {
+      const originalExecute = tool.execute;
+      tool.execute = async (args) => {
+        const result = await originalExecute(args);
+        const resultText = JSON.stringify(result);
+        if (resultText.length <= maxSize) {
+          return result;
+        }
+        if (!tempDir) {
+          tempDir = await mkdtemp(join(tmpdir2(), "mcpc-results-"));
+        }
+        const safeToolName = encodeURIComponent(context.toolName ?? "tool");
+        const fileName = `${safeToolName}-${Date.now()}.txt`;
+        const filePath = join(tempDir, fileName);
+        await writeFile(filePath, resultText);
+        const preview = resultText.slice(0, previewSize);
+        return {
+          content: [
+            {
+              type: "text",
+              text: `**Result too large (${resultText.length} chars), saved to file**
+
+\u{1F4C1} **File:** ${filePath}
+\u{1F4CA} **Size:** ${(resultText.length / 1024).toFixed(1)} KB
+
+**Preview (${previewSize} chars):**
+\`\`\`
+${preview}
+\`\`\`
+
+**To read/understand the full content:**
+- Use the \`search-tool-result\` tool with pattern: \`search-tool-result {"pattern": "your-search-term"}\`
+- Search supports regex patterns for advanced queries`
+            }
+          ]
+        };
+      };
+      return tool;
+    }
+  };
+}
+var defaultLargeResultPlugin = createLargeResultPlugin({
+  maxSize: 8e3,
+  previewSize: 4e3
+});
+var large_result_default = defaultLargeResultPlugin;
+export {
+  createLargeResultPlugin,
+  createSearchPlugin,
+  large_result_default as defaultLargeResultPlugin,
+  search_tool_default as defaultSearchPlugin
+};

package/src/plugins/large-result.mjs

@@ -0,0 +1,290 @@
+// ../__mcpc__core_0.2.0-beta.10/node_modules/@mcpc/core/src/plugins/large-result.ts
+import { mkdtemp, writeFile } from "node:fs/promises";
+import { join } from "node:path";
+import { tmpdir as tmpdir2 } from "node:os";
+
+// ../__mcpc__core_0.2.0-beta.10/node_modules/@mcpc/core/src/plugins/search-tool.js
+import rg from "@mcpc-tech/ripgrep-napi";
+import { tmpdir } from "node:os";
+import { jsonSchema } from "ai";
+import { resolve } from "node:path";
+import { relative } from "node:path";
+function createSearchPlugin(options = {}) {
+  const maxResults = options.maxResults || 20;
+  const maxOutputSize = options.maxOutputSize || 5e3;
+  const allowedSearchDir = options.allowedDir || tmpdir();
+  const timeoutMs = options.timeoutMs || 3e4;
+  const global = options.global ?? true;
+  return {
+    name: "plugin-search",
+    configureServer: (server) => {
+      server.tool("search-tool-result", `Search for text patterns in files and directories. Use this to find specific content, code, or information within files. Provide a simple literal string or a regular expression. If your pattern is a regex, ensure it's valid; otherwise use quotes or escape special characters to treat it as a literal string.
+Only search within the allowed directory: ${allowedSearchDir}`, jsonSchema({
+        type: "object",
+        properties: {
+          pattern: {
+            type: "string",
+            description: "Text to search for. Can be a plain string or a regular expression. For regexes, don't include delimiters (e.g. use `^foo` not `/^foo/`). If you get a regex parse error, try escaping special chars or using a simpler literal search."
+          },
+          path: {
+            type: "string",
+            description: "File or folder path to limit the search (optional). Must be within the allowed directory."
+          },
+          maxResults: {
+            type: "number",
+            description: "Maximum number of matches to return (optional). Lower this to reduce output size and runtime."
+          }
+        },
+        required: [
+          "pattern"
+        ]
+      }), async (args) => {
+        const isBroad = (raw) => {
+          const t = (raw ?? "").trim();
+          if (!t) return true;
+          if (/^[*.\s]{2,}$/.test(t)) return true;
+          if (t === ".*" || t === "." || t === "^.*$") return true;
+          if (/^\^?\.\*\$?$/.test(t)) return true;
+          if (/^\\s?\*+$/.test(t)) return true;
+          return false;
+        };
+        const appendMatchSafely = (current, addition, limit) => {
+          if ((current + addition).length > limit) {
+            return {
+              current,
+              added: false
+            };
+          }
+          return {
+            current: current + addition,
+            added: true
+          };
+        };
+        try {
+          const requestedPath = args.path || allowedSearchDir;
+          const limit = args.maxResults || maxResults;
+          if (args.path) {
+            const resolvedRequested = resolve(args.path);
+            const resolvedAllowed = resolve(allowedSearchDir);
+            const relativePath = relative(resolvedAllowed, resolvedRequested);
+            if (relativePath && relativePath.startsWith("..")) {
+              return {
+                content: [
+                  {
+                    type: "text",
+                    text: `\u274C Path "${args.path}" not allowed. Must be within: ${allowedSearchDir}`
+                  }
+                ],
+                isError: true
+              };
+            }
+          }
+          const searchPath = requestedPath;
+          const rawPattern = args.pattern ?? "";
+          if (isBroad(rawPattern)) {
+            return {
+              content: [
+                {
+                  type: "text",
+                  text: `\u274C Search pattern too broad: "${rawPattern}"
+Provide a more specific pattern (e.g. include a filename fragment, a keyword, or limit with the "path" parameter). Avoid patterns that only contain wildcards like "*" or ".*".`
+                }
+              ],
+              isError: true
+            };
+          }
+          let timeoutId;
+          const timeoutPromise = new Promise((_, reject) => {
+            timeoutId = setTimeout(() => {
+              reject(new Error(`Search timeout after ${timeoutMs}ms`));
+            }, timeoutMs);
+          });
+          console.log(`Searching for "${args.pattern}" in ${searchPath}`);
+          const searchPromise = new Promise((resolve2, reject) => {
+            try {
+              const result2 = rg.search(args.pattern, [
+                searchPath
+              ]);
+              resolve2(result2);
+            } catch (error) {
+              reject(error);
+            }
+          });
+          const result = await Promise.race([
+            searchPromise,
+            timeoutPromise
+          ]);
+          if (timeoutId) clearTimeout(timeoutId);
+          if (!result.success || !result.matches?.length) {
+            return {
+              content: [
+                {
+                  type: "text",
+                  text: `No matches found for: "${args.pattern}"
+
+Try:
+- **Simpler pattern** or \`*\`
+- Check if files exist in: ${searchPath}
+- Use specific file path`
+                }
+              ]
+            };
+          }
+          const matches = result.matches.slice(0, limit);
+          let output = `Found ${result.matches.length} matches (showing up to ${matches.length}):
+
+`;
+          let matchesIncluded = 0;
+          for (const match of matches) {
+            const baseMatchText = `**${match.path}:${match.lineNumber}**
+`;
+            const fullMatchText = `${baseMatchText}\`\`\`
+${match.line}
+\`\`\`
+
+`;
+            const res = appendMatchSafely(output, fullMatchText, maxOutputSize);
+            if (!res.added) {
+              if (matchesIncluded === 0) {
+                const remainingSpace = maxOutputSize - output.length - 100;
+                if (remainingSpace > 50) {
+                  const truncatedLine = match.line.slice(0, remainingSpace);
+                  output += `${baseMatchText}\`\`\`
+${truncatedLine}...
+\`\`\`
+
+`;
+                  output += `\u26A0\uFE0F Content truncated
+`;
+                  matchesIncluded++;
+                } else {
+                  output += `\u26A0\uFE0F Content too large, use specific file path
+`;
+                }
+              }
+              break;
+            }
+            output = res.current;
+            matchesIncluded++;
+          }
+          if (matchesIncluded < matches.length) {
+            output += `
+\u26A0\uFE0F Showing ${matchesIncluded}/${matches.length} matches (size limit)
+`;
+            output += `
+For more results:
+`;
+            output += `- Use specific pattern: "${args.pattern} keyword"
+`;
+            output += `- Search specific file: {"pattern": "${args.pattern}", "path": "/file.txt"}
+`;
+            output += `- Use fewer results: {"maxResults": 5}`;
+          }
+          return {
+            content: [
+              {
+                type: "text",
+                text: output
+              }
+            ]
+          };
+        } catch (error) {
+          const errorMsg = error instanceof Error ? error.message : String(error);
+          const isTimeout = errorMsg.includes("timeout");
+          return {
+            content: [
+              {
+                type: "text",
+                text: `Search error: ${errorMsg}
+
+${isTimeout ? `Timeout after ${timeoutMs}ms. Try simpler pattern or smaller directory.` : `Check pattern syntax or directory exists.`}`
+              }
+            ]
+          };
+        }
+      }, {
+        internal: !global
+      });
+    }
+  };
+}
+var defaultSearchPlugin = createSearchPlugin({
+  global: true,
+  maxResults: 20,
+  maxOutputSize: 5e3,
+  caseSensitive: false,
+  timeoutMs: 3e4
+});
+
+// ../__mcpc__core_0.2.0-beta.10/node_modules/@mcpc/core/src/plugins/large-result.ts
+function createLargeResultPlugin(options = {}) {
+  const maxSize = options.maxSize || 8e3;
+  const previewSize = options.previewSize || 4e3;
+  let tempDir = options.tempDir || null;
+  const serversConfigured = /* @__PURE__ */ new WeakSet();
+  const searchConfig = {
+    maxResults: options.search?.maxResults || 15,
+    maxOutputSize: options.search?.maxOutputSize || 4e3,
+    global: true
+  };
+  return {
+    name: "plugin-large-result-handler",
+    configureServer: async (server) => {
+      if (!serversConfigured.has(server)) {
+        const searchPlugin = createSearchPlugin(searchConfig);
+        await server.addPlugin(searchPlugin);
+        serversConfigured.add(server);
+      }
+    },
+    transformTool: (tool, context) => {
+      const originalExecute = tool.execute;
+      tool.execute = async (args) => {
+        const result = await originalExecute(args);
+        const resultText = JSON.stringify(result);
+        if (resultText.length <= maxSize) {
+          return result;
+        }
+        if (!tempDir) {
+          tempDir = await mkdtemp(join(tmpdir2(), "mcpc-results-"));
+        }
+        const safeToolName = encodeURIComponent(context.toolName ?? "tool");
+        const fileName = `${safeToolName}-${Date.now()}.txt`;
+        const filePath = join(tempDir, fileName);
+        await writeFile(filePath, resultText);
+        const preview = resultText.slice(0, previewSize);
+        return {
+          content: [
+            {
+              type: "text",
+              text: `**Result too large (${resultText.length} chars), saved to file**
+
+\u{1F4C1} **File:** ${filePath}
+\u{1F4CA} **Size:** ${(resultText.length / 1024).toFixed(1)} KB
+
+**Preview (${previewSize} chars):**
+\`\`\`
+${preview}
+\`\`\`
+
+**To read/understand the full content:**
+- Use the \`search-tool-result\` tool with pattern: \`search-tool-result {"pattern": "your-search-term"}\`
+- Search supports regex patterns for advanced queries`
+            }
+          ]
+        };
+      };
+      return tool;
+    }
+  };
+}
+var defaultLargeResultPlugin = createLargeResultPlugin({
+  maxSize: 8e3,
+  previewSize: 4e3
+});
+var createPlugin = createLargeResultPlugin;
+var large_result_default = defaultLargeResultPlugin;
+export {
+  createLargeResultPlugin,
+  createPlugin,
+  large_result_default as default
+};