@atlaskit/ads-mcp 0.13.8 → 0.14.0

package/CHANGELOG.md

@@ -1,5 +1,19 @@
 # @atlaskit/ads-mcp
 
+## 0.14.0
+
+### Minor Changes
+
+- [`9450f7060eda0`](https://bitbucket.org/atlassian/atlassian-frontend-monorepo/commits/9450f7060eda0) -
+  Created "lint rule" tool that documents lint rules in ADS MCP. It sources its content from the
+  structured docs.
+
+## 0.13.9
+
+### Patch Changes
+
+- Updated dependencies
+
 ## 0.13.8
 
 ### Patch Changes

package/dist/cjs/index.js

@@ -21,6 +21,7 @@ var _getAllIcons = require("./tools/get-all-icons");
 var _getAllTokens = require("./tools/get-all-tokens");
 var _getComponents = require("./tools/get-components");
 var _getIcons = require("./tools/get-icons");
+var _getLintRules = require("./tools/get-lint-rules");
 var _getTokens = require("./tools/get-tokens");
 var _i18nConversion = require("./tools/i18n-conversion");
 var _migrationGuides = require("./tools/migration-guides");
@@ -109,6 +110,11 @@ var getToolRegistry = exports.getToolRegistry = function getToolRegistry() {
       inputSchema: _getIcons.getIconsInputSchema,
       tool: _getIcons.listGetIconsTool
     };
+    baseTools[_getLintRules.listGetLintRulesTool.name] = {
+      handler: _getLintRules.getLintRulesTool,
+      inputSchema: _getLintRules.getLintRulesInputSchema,
+      tool: _getLintRules.listGetLintRulesTool
+    };
   } else {
     baseTools[_getAllTokens.listGetAllTokensTool.name] = {
       handler: _getAllTokens.getAllTokensTool,

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

@@ -0,0 +1,126 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.listGetLintRulesTool = exports.getLintRulesTool = exports.getLintRulesInputSchema = void 0;
+var _regenerator = _interopRequireDefault(require("@babel/runtime/regenerator"));
+var _asyncToGenerator2 = _interopRequireDefault(require("@babel/runtime/helpers/asyncToGenerator"));
+var _fuse = _interopRequireDefault(require("fuse.js"));
+var _zod = require("zod");
+var _helpers = require("../../helpers");
+var _lintRulesStructuredContent = require("./lint-rules-structured-content.codegen");
+var getLintRulesInputSchema = exports.getLintRulesInputSchema = _zod.z.object({
+  terms: _zod.z.array(_zod.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: _zod.z.number().default(1).describe('Maximum number of results per search term in the array (default: 1)').optional(),
+  exactName: _zod.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()
+});
+var listGetLintRulesTool = exports.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: (0, _helpers.zodToJsonSchema)(getLintRulesInputSchema)
+};
+var getLintRulesTool = exports.getLintRulesTool = /*#__PURE__*/function () {
+  var _ref = (0, _asyncToGenerator2.default)( /*#__PURE__*/_regenerator.default.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 _regenerator.default.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(_helpers.cleanQuery);
+          ruleDocs = _lintRulesStructuredContent.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.default(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);
+  };
+}();