@kepler.gl/mcp 0.0.0-stage → 3.3.0-alpha.19

package/dist/cjs/commands/dataset-context-command.js

@@ -0,0 +1,87 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.datasetContextCommandId = void 0;
+exports.getDatasetContextCommand = getDatasetContextCommand;
+var _regenerator = _interopRequireDefault(require("@babel/runtime/regenerator"));
+var _asyncToGenerator2 = _interopRequireDefault(require("@babel/runtime/helpers/asyncToGenerator"));
+var _zod = require("zod");
+// SPDX-License-Identifier: MIT
+// Copyright contributors to the kepler.gl project
+
+var datasetContextCommandId = exports.datasetContextCommandId = 'map.get-dataset-context';
+function getDatasetContextCommand(ctx) {
+  return {
+    id: datasetContextCommandId,
+    name: 'Get dataset context',
+    group: 'Map',
+    description: 'Get all loaded kepler.gl datasets with their fields and layer configurations. ' + 'Returns each dataset name, id, field name→type mappings, and the layers ' + '(id, label, type, geometryMode, geometryColumns) bound to it.',
+    metadata: {
+      readOnly: true,
+      riskLevel: 'low',
+      idempotent: true
+    },
+    inputSchema: _zod.z.object({}),
+    execute: function () {
+      var _execute = (0, _asyncToGenerator2["default"])(/*#__PURE__*/_regenerator["default"].mark(function _callee() {
+        var context, trimmed, datasets, count;
+        return _regenerator["default"].wrap(function _callee$(_context) {
+          while (1) switch (_context.prev = _context.next) {
+            case 0:
+              _context.prev = 0;
+              context = ctx.getDatasetContext();
+              if (context) {
+                _context.next = 4;
+                break;
+              }
+              return _context.abrupt("return", {
+                success: false,
+                commandId: datasetContextCommandId,
+                error: 'No datasets or layers available.',
+                data: {
+                  instruction: 'Please ensure the kepler.gl map has loaded datasets and try again.'
+                }
+              });
+            case 4:
+              // Accept either a pure-JSON context or the two-part "human line + JSON"
+              // format: hosts may return either, so don't assume the first line is a
+              // preface.
+              trimmed = context.trim();
+              datasets = JSON.parse(trimmed.startsWith('[') || trimmed.startsWith('{') ? trimmed : context.split('\n').slice(1).join('\n'));
+              count = Array.isArray(datasets) ? datasets.length : Object.keys(datasets).length;
+              return _context.abrupt("return", {
+                success: true,
+                commandId: datasetContextCommandId,
+                data: {
+                  details: "".concat(count, " dataset(s) loaded."),
+                  datasets: datasets
+                }
+              });
+            case 10:
+              _context.prev = 10;
+              _context.t0 = _context["catch"](0);
+              return _context.abrupt("return", {
+                success: false,
+                commandId: datasetContextCommandId,
+                error: _context.t0 instanceof Error ? _context.t0.message : 'Unknown error',
+                data: {
+                  instruction: 'Please ensure the kepler.gl map is properly loaded and try again.'
+                }
+              });
+            case 13:
+            case "end":
+              return _context.stop();
+          }
+        }, _callee, null, [[0, 10]]);
+      }));
+      function execute() {
+        return _execute.apply(this, arguments);
+      }
+      return execute;
+    }()
+  };
+}
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,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

package/dist/cjs/commands/index.js

@@ -0,0 +1,230 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.KEPLER_COMMAND_OWNER = void 0;
+Object.defineProperty(exports, "LLM_PREVIEW_MAX_TOTAL_LENGTH", {
+  enumerable: true,
+  get: function get() {
+    return _utils.LLM_PREVIEW_MAX_TOTAL_LENGTH;
+  }
+});
+Object.defineProperty(exports, "LLM_PREVIEW_MAX_VALUE_LENGTH", {
+  enumerable: true,
+  get: function get() {
+    return _utils.LLM_PREVIEW_MAX_VALUE_LENGTH;
+  }
+});
+Object.defineProperty(exports, "NUMBER_OF_ROWS_RETURN_TO_LLM", {
+  enumerable: true,
+  get: function get() {
+    return _utils.NUMBER_OF_ROWS_RETURN_TO_LLM;
+  }
+});
+Object.defineProperty(exports, "arrowTableToObjects", {
+  enumerable: true,
+  get: function get() {
+    return _utils.arrowTableToObjects;
+  }
+});
+Object.defineProperty(exports, "asInputSchema", {
+  enumerable: true,
+  get: function get() {
+    return _commandWrappers.asInputSchema;
+  }
+});
+Object.defineProperty(exports, "buildAddColumnPayload", {
+  enumerable: true,
+  get: function get() {
+    return _utils.buildAddColumnPayload;
+  }
+});
+Object.defineProperty(exports, "convertArrowRowToObject", {
+  enumerable: true,
+  get: function get() {
+    return _utils.convertArrowRowToObject;
+  }
+});
+Object.defineProperty(exports, "datasetNameToTableName", {
+  enumerable: true,
+  get: function get() {
+    return _utils.datasetNameToTableName;
+  }
+});
+Object.defineProperty(exports, "formatResultsForLLM", {
+  enumerable: true,
+  get: function get() {
+    return _utils.formatResultsForLLM;
+  }
+});
+Object.defineProperty(exports, "getAddColumnCommand", {
+  enumerable: true,
+  get: function get() {
+    return _addColumnCommand.getAddColumnCommand;
+  }
+});
+Object.defineProperty(exports, "getAddLayerCommand", {
+  enumerable: true,
+  get: function get() {
+    return _layerCreationCommand.getAddLayerCommand;
+  }
+});
+Object.defineProperty(exports, "getAddTimeFilterCommand", {
+  enumerable: true,
+  get: function get() {
+    return _timeFilterCommand.getAddTimeFilterCommand;
+  }
+});
+Object.defineProperty(exports, "getBasemapCommand", {
+  enumerable: true,
+  get: function get() {
+    return _basemapCommand.getBasemapCommand;
+  }
+});
+Object.defineProperty(exports, "getDatasetContextCommand", {
+  enumerable: true,
+  get: function get() {
+    return _datasetContextCommand.getDatasetContextCommand;
+  }
+});
+exports.getKeplerCommands = getKeplerCommands;
+Object.defineProperty(exports, "getLoadDataCommand", {
+  enumerable: true,
+  get: function get() {
+    return _loadDataCommand.getLoadDataCommand;
+  }
+});
+Object.defineProperty(exports, "getMapBoundaryCommand", {
+  enumerable: true,
+  get: function get() {
+    return _boundaryCommand.getMapBoundaryCommand;
+  }
+});
+Object.defineProperty(exports, "getSaveDataCommand", {
+  enumerable: true,
+  get: function get() {
+    return _saveDataCommand.getSaveDataCommand;
+  }
+});
+Object.defineProperty(exports, "getSplitViewCommand", {
+  enumerable: true,
+  get: function get() {
+    return _splitViewCommand.getSplitViewCommand;
+  }
+});
+Object.defineProperty(exports, "getTableCommand", {
+  enumerable: true,
+  get: function get() {
+    return _tableCommand.getTableCommand;
+  }
+});
+Object.defineProperty(exports, "getToggleTimeFilterCommand", {
+  enumerable: true,
+  get: function get() {
+    return _toggleTimeFilterCommand.getToggleTimeFilterCommand;
+  }
+});
+Object.defineProperty(exports, "getUpdateLayerColorCommand", {
+  enumerable: true,
+  get: function get() {
+    return _layerStyleCommand.getUpdateLayerColorCommand;
+  }
+});
+Object.defineProperty(exports, "getValuesFromDataset", {
+  enumerable: true,
+  get: function get() {
+    return _utils.getValuesFromDataset;
+  }
+});
+Object.defineProperty(exports, "getValuesFromVectorTileLayer", {
+  enumerable: true,
+  get: function get() {
+    return _utils.getValuesFromVectorTileLayer;
+  }
+});
+Object.defineProperty(exports, "getViewModeCommand", {
+  enumerable: true,
+  get: function get() {
+    return _viewModeCommand.getViewModeCommand;
+  }
+});
+Object.defineProperty(exports, "guessDefaultLayer", {
+  enumerable: true,
+  get: function get() {
+    return _layerCreationCommand.guessDefaultLayer;
+  }
+});
+Object.defineProperty(exports, "isObjectColumn", {
+  enumerable: true,
+  get: function get() {
+    return _utils.isObjectColumn;
+  }
+});
+Object.defineProperty(exports, "isVectorTileLayer", {
+  enumerable: true,
+  get: function get() {
+    return _utils.isVectorTileLayer;
+  }
+});
+Object.defineProperty(exports, "restoreObjectColumns", {
+  enumerable: true,
+  get: function get() {
+    return _utils.restoreObjectColumns;
+  }
+});
+Object.defineProperty(exports, "stringifyObjectColumn", {
+  enumerable: true,
+  get: function get() {
+    return _utils.stringifyObjectColumn;
+  }
+});
+Object.defineProperty(exports, "tableToLLMResult", {
+  enumerable: true,
+  get: function get() {
+    return _utils.tableToLLMResult;
+  }
+});
+Object.defineProperty(exports, "toolToCommand", {
+  enumerable: true,
+  get: function get() {
+    return _commandWrappers.toolToCommand;
+  }
+});
+var _basemapCommand = require("./basemap-command");
+var _viewModeCommand = require("./view-mode-command");
+var _boundaryCommand = require("./boundary-command");
+var _layerCreationCommand = require("./layer-creation-command");
+var _layerStyleCommand = require("./layer-style-command");
+var _loadDataCommand = require("./load-data-command");
+var _saveDataCommand = require("./save-data-command");
+var _tableCommand = require("./table-command");
+var _addColumnCommand = require("./add-column-command");
+var _timeFilterCommand = require("./time-filter-command");
+var _toggleTimeFilterCommand = require("./toggle-time-filter-command");
+var _splitViewCommand = require("./split-view-command");
+var _datasetContextCommand = require("./dataset-context-command");
+var _commandWrappers = require("./command-wrappers");
+var _utils = require("./utils");
+// SPDX-License-Identifier: MIT
+// Copyright contributors to the kepler.gl project
+
+/**
+ * Owner string under which all kepler-ai commands are registered in the
+ * room-store command registry. Used by `registerCommandsForOwner` /
+ * `unregisterCommandsForOwner` in the host's store wiring.
+ */
+var KEPLER_COMMAND_OWNER = exports.KEPLER_COMMAND_OWNER = 'kepler-ai';
+
+/**
+ * Build the kepler-gl map-mutation commands for a given `KeplerContext`.
+ * Returns a map keyed by command id (e.g. `map.set-basemap`) so the registry
+ * registration is a flat merge.
+ */
+function getKeplerCommands(ctx) {
+  var commands = [(0, _basemapCommand.getBasemapCommand)(ctx), (0, _viewModeCommand.getViewModeCommand)(ctx), (0, _boundaryCommand.getMapBoundaryCommand)(ctx), (0, _layerCreationCommand.getAddLayerCommand)(ctx), (0, _layerStyleCommand.getUpdateLayerColorCommand)(ctx), (0, _loadDataCommand.getLoadDataCommand)(ctx), (0, _saveDataCommand.getSaveDataCommand)(ctx), (0, _tableCommand.getTableCommand)(ctx), (0, _addColumnCommand.getAddColumnCommand)(ctx), (0, _timeFilterCommand.getAddTimeFilterCommand)(ctx), (0, _toggleTimeFilterCommand.getToggleTimeFilterCommand)(ctx), (0, _splitViewCommand.getSplitViewCommand)(ctx), (0, _datasetContextCommand.getDatasetContextCommand)(ctx)];
+  return Object.fromEntries(commands.map(function (c) {
+    return [c.id, c];
+  }));
+}
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,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