@atlaskit/ads-mcp 0.13.9 → 0.15.0

package/dist/esm/tools/get-lint-rules/index.js

@@ -0,0 +1,119 @@
+import _asyncToGenerator from "@babel/runtime/helpers/asyncToGenerator";
+import _regeneratorRuntime from "@babel/runtime/regenerator";
+import Fuse from 'fuse.js';
+import { z } from 'zod';
+import { cleanQuery, zodToJsonSchema } from '../../helpers';
+import { lintRulesStructuredContent } from './lint-rules-structured-content.codegen';
+export var getLintRulesInputSchema = z.object({
+  terms: z.array(z.string()).default([]).describe('An array of search terms to find lint rules by name or description, eg. `["icon-label", "xcss", "design token"]`. If empty or not provided, returns all lint rules.').optional(),
+  limit: z.number().default(1).describe('Maximum number of results per search term in the array (default: 1)').optional(),
+  exactName: z.boolean().default(false).describe('Enable to explicitly search lint rules by the exact rule name match (when you know the rule name, but need more details)').optional()
+});
+export var listGetLintRulesTool = {
+  name: 'ads_get_lint_rules',
+  description: "Get Atlassian Design System ESLint rule documentation (constellation) with optional search functionality.\n\n- If search parameters are provided, searches for lint rules matching the criteria.\n- If no search parameters are provided, returns all lint rules.\n\nExample: use this tool to look up documentation for rules like icon-label, ensure-proper-xcss-usage, or no-deprecated-apis.",
+  annotations: {
+    title: 'Get ADS lint rules',
+    readOnlyHint: true,
+    destructiveHint: false,
+    idempotentHint: true,
+    openWorldHint: true
+  },
+  inputSchema: zodToJsonSchema(getLintRulesInputSchema)
+};
+export var getLintRulesTool = /*#__PURE__*/function () {
+  var _ref = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime.mark(function _callee(params) {
+    var _params$terms, terms, _params$limit, limit, _params$exactName, exactName, searchTerms, ruleDocs, allRulesMarkdown, exactNameMatches, _formattedRules, fuse, results, uniqueResults, matchedRules, formattedRules;
+    return _regeneratorRuntime.wrap(function _callee$(_context) {
+      while (1) switch (_context.prev = _context.next) {
+        case 0:
+          _params$terms = params.terms, terms = _params$terms === void 0 ? [] : _params$terms, _params$limit = params.limit, limit = _params$limit === void 0 ? 1 : _params$limit, _params$exactName = params.exactName, exactName = _params$exactName === void 0 ? false : _params$exactName;
+          searchTerms = terms.filter(Boolean).map(cleanQuery);
+          ruleDocs = lintRulesStructuredContent; // If no search terms provided, return all rules formatted as Markdown
+          if (!(searchTerms.length === 0)) {
+            _context.next = 6;
+            break;
+          }
+          allRulesMarkdown = ruleDocs.map(function (rule) {
+            return rule.content;
+          }).join('\n\n');
+          return _context.abrupt("return", {
+            content: [{
+              type: 'text',
+              text: allRulesMarkdown
+            }]
+          });
+        case 6:
+          if (!exactName) {
+            _context.next = 10;
+            break;
+          }
+          exactNameMatches = searchTerms.map(function (term) {
+            return ruleDocs.find(function (rule) {
+              return rule.ruleName.toLowerCase() === term.toLowerCase();
+            });
+          }).filter(function (rule) {
+            return rule !== undefined;
+          });
+          _formattedRules = exactNameMatches.map(function (rule) {
+            return rule.content;
+          }).join('\n\n');
+          return _context.abrupt("return", {
+            content: [{
+              type: 'text',
+              text: _formattedRules
+            }]
+          });
+        case 10:
+          // use Fuse.js to fuzzy-search for the rules
+          fuse = new Fuse(ruleDocs, {
+            keys: [{
+              name: 'ruleName',
+              weight: 3
+            }, {
+              name: 'description',
+              weight: 2
+            }, {
+              name: 'content',
+              weight: 1
+            }],
+            threshold: 0.4
+          });
+          results = searchTerms.map(function (term) {
+            var exactNameMatch = ruleDocs.find(function (rule) {
+              return rule.ruleName.toLowerCase() === term.toLowerCase();
+            });
+            if (exactNameMatch) {
+              return [{
+                item: exactNameMatch
+              }];
+            }
+            return fuse.search(term).slice(0, limit);
+          }).flat(); // Remove duplicates based on ruleName
+          uniqueResults = results.filter(function (result, index, arr) {
+            return arr.findIndex(function (r) {
+              return r.item.ruleName === result.item.ruleName;
+            }) === index;
+          });
+          matchedRules = uniqueResults.map(function (result) {
+            return result.item;
+          });
+          formattedRules = matchedRules.map(function (rule) {
+            return rule.content;
+          }).join('\n\n');
+          return _context.abrupt("return", {
+            content: [{
+              type: 'text',
+              text: formattedRules
+            }]
+          });
+        case 16:
+        case "end":
+          return _context.stop();
+      }
+    }, _callee);
+  }));
+  return function getLintRulesTool(_x) {
+    return _ref.apply(this, arguments);
+  };
+}();