rhombus-node-mcp 0.1.21 → 0.1.23

package/dist/types.js

@@ -9,24 +9,3 @@ export function createUuidSchema() {
       It contains only alphanumeric characters, digits, hyphens, and underscores.`);
 }
 export const UUID = createUuidSchema();
-export const VideoWallSettings = z.object({
-    rowCount: z.number(),
-    columnCount: z.number(),
-    intervalSeconds: z.number().nullable(),
-    rotateStrategy: z.enum(["none", "motion", "interval"]),
-});
-export const CreateVideoWallOptions = z
-    .object({
-    displayName: z.string().nullable().describe("What to call the video wall"),
-    orgUuid: z.string().describe("The uuid of the organization"),
-    deviceList: z
-        .array(z.string())
-        .min(1)
-        .describe("The list of camera uuids (unique identifiers) to exist in the video wall.  You must provide this manually by prompting the user at least once."),
-    othersCanEdit: z
-        .boolean()
-        .nullable()
-        .describe("Whether or not other users can edit the wall, defaults to false"),
-    settings: VideoWallSettings,
-})
-    .nullable();

package/dist/util.js

@@ -2,6 +2,8 @@ import { z } from "zod";
 import fs from "fs";
 import path from "path";
 import { DateTime } from "luxon";
+import { filterIncludedFields, applyFilterBy } from "./filtering-utils.js";
+export { INCLUDE_FIELDS_ARG, FILTER_BY_ARG, filterIncludedFields, applyFilterBy, zodToDotNotationPaths, createFilteringProxy } from "./filtering-utils.js";
 export function generateRandomString(length) {
     const characters = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789";
     let result = "";
@@ -24,6 +26,9 @@ export function extractFromToolExtra(_extra) {
         sessionId: extra.sessionId,
     };
 }
+// ---------------------------------------------------------------------------
+// File utilities
+// ---------------------------------------------------------------------------
 /**
  * Get all file paths in a directory in a directory
  *
@@ -52,6 +57,9 @@ export function getFilePathsInDirectory(dirPath) {
     }
     return filePaths;
 }
+// ---------------------------------------------------------------------------
+// Tool content helpers
+// ---------------------------------------------------------------------------
 /**
  * Returns an object in the form expected by `server.tool`
  */
@@ -66,20 +74,38 @@ export function createToolTextContent(content) {
     };
 }
 /**
- * Returns strucutred content expected by `server.tool`
- * The generic type T allows for type safety. Set T to the output schema of the tool, and your content will be type checked
+ * Returns structured content expected by `server.tool`.
+ * Optionally applies programmatic field projection (includeFields) and
+ * row filtering (filterBy) before serialising.
+ *
+ * The generic type T allows for type safety. Set T to the output schema of the
+ * tool and your content will be type-checked.
+ *
+ * filterBy is applied first (prune rows), then includeFields (prune columns),
+ * which minimises output size optimally.
  */
-export function createToolStructuredContent(content) {
+export function createToolStructuredContent(content, opts) {
+    // biome-ignore lint/suspicious/noExplicitAny: intentional runtime manipulation
+    let result = content;
+    if (opts?.filterBy?.length) {
+        result = applyFilterBy(result, opts.filterBy) ?? result;
+    }
+    if (opts?.includeFields?.length) {
+        result = filterIncludedFields(result, opts.includeFields) ?? result;
+    }
     return {
         content: [
             {
                 type: "text",
-                text: JSON.stringify(content),
+                text: JSON.stringify(result),
             },
         ],
-        structuredContent: content,
+        structuredContent: result,
     };
 }
+// ---------------------------------------------------------------------------
+// removeNullFields
+// ---------------------------------------------------------------------------
 /**
  * Recursively removes fields with null values from a JavaScript object.
  * If a nested object becomes empty after removing nulls, it will also be removed.
@@ -124,58 +150,9 @@ export function removeNullFields(obj) {
     }
     return Object.keys(cleanedObject).length > 0 ? cleanedObject : undefined;
 }
-export function filterIncludedFields(obj, fieldsToInclude) {
-    if (!fieldsToInclude || fieldsToInclude.length === 0) {
-        return obj;
-    }
-    if (Array.isArray(obj)) {
-        return obj
-            .map(item => filterIncludedFields(item, fieldsToInclude))
-            .filter(item => {
-            if (item === undefined || item === null) {
-                return false;
-            }
-            if (Array.isArray(item)) {
-                return item.length > 0;
-            }
-            if (typeof item === "object") {
-                return Object.keys(item).length > 0;
-            }
-            // Keep primitives
-            return true;
-        });
-    }
-    if (typeof obj === "object" && obj !== null) {
-        const newObj = {};
-        for (const key in obj) {
-            if (Object.prototype.hasOwnProperty.call(obj, key)) {
-                if (fieldsToInclude.includes(key)) {
-                    newObj[key] = obj[key];
-                }
-                else {
-                    const result = filterIncludedFields(obj[key], fieldsToInclude);
-                    if (result !== undefined && result !== null) {
-                        if (Array.isArray(result)) {
-                            if (result.length > 0) {
-                                newObj[key] = result;
-                            }
-                        }
-                        else if (typeof result === "object") {
-                            if (Object.keys(result).length > 0) {
-                                newObj[key] = result;
-                            }
-                        }
-                        else {
-                            newObj[key] = result;
-                        }
-                    }
-                }
-            }
-        }
-        return Object.keys(newObj).length > 0 ? newObj : undefined;
-    }
-    return undefined;
-}
+// ---------------------------------------------------------------------------
+// formatTimestamp
+// ---------------------------------------------------------------------------
 /**
  * Formats a timestamp in milliseconds to a human-readable date string
  * Format: "February 24, 2025 at 3:23 PM"

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "rhombus-node-mcp",
-  "version": "0.1.21",
+  "version": "0.1.23",
   "description": "MCP server for Rhombus API",
   "keywords": [
     "ai",
@@ -10,11 +10,11 @@
   ],
   "homepage": "https://modelcontextprotocol.io",
   "bugs": {
-    "url": "https://github.com/modelcontextprotocol/servers/issues"
+    "url": "https://github.com/RhombusSystems/rhombus-node-mcp/issues"
   },
   "repository": {
     "type": "git",
-    "url": "git+https://github.com/modelcontextprotocol/servers.git"
+    "url": "git+https://github.com/RhombusSystems/rhombus-node-mcp.git"
   },
   "license": "MIT",
   "author": "Model Context Protocol (https://modelcontextprotocol.io)",
@@ -28,6 +28,8 @@
     "build": "rm -rf dist && tsc && chmod +x dist/*.js",
     "docker:build": "docker build -t rhombussystems/mcp-server-rhombus .",
     "start": "node dist/index.js",
+    "start:http": "TRANSPORT_TYPE=streamable-http node dist/index.js",
+    "start:stdio": "TRANSPORT_TYPE=stdio node dist/index.js",
     "prepare": "npm run build",
     "watch": "npm run clean && tsc --watch",
     "generate-schemas": "npx tsx scripts/generate-zod-schemas.ts",
@@ -45,7 +47,7 @@
     "dist"
   ],
   "dependencies": {
-    "@modelcontextprotocol/sdk": "^1.21.1",
+    "@modelcontextprotocol/sdk": "^1.21.2",
     "axios": "^1.11.0",
     "cheerio": "^1.1.2",
     "chrono-node": "^2.8.0",
@@ -76,4 +78,4 @@
   "engines": {
     "node": ">=18"
   }
-}
+}

package/dist/disabled-tools/semantic-search-tool.js

@@ -1,90 +0,0 @@
-import { FaissSearchService } from '../services/faiss-search-service.js';
-import { createToolTextContent } from '../util.js';
-import { logger } from '../logger.js';
-import { TOOL_ARGS } from '../types/semantic-search-tool-types.js';
-// Constants following coding style guidelines
-const DEFAULT_SEARCH_LIMIT = 3;
-const DEFAULT_MIN_SIMILARITY = 0.3;
-const TOOL_NAME = "semantic-search";
-const TOOL_DESCRIPTION = `
-This tool performs semantic search across the Rhombus knowledge base using AI embeddings and vector similarity.
-
-It searches through documentation, blog posts, support articles, and other content to find the most relevant 
-information based on the meaning of your query, not just keyword matching.
-
-The tool returns an array of search results, each containing:
-- sourceTitle: The title of the source document
-- sourceUrl: The URL where the content can be found
-- chunkText: The relevant text snippet that matches your query
-
-Use this tool when you need to find information about:
-- Camera features, specifications, or comparisons
-- Installation and setup procedures  
-- Technical troubleshooting
-- Product capabilities and benefits
-- Access control and security features
-- Cloud storage and management
-- Any other Rhombus-related topics
-`;
-// Singleton instance for reuse across searches
-let globalSearchService = null;
-let isGlobalServiceInitialized = false;
-async function getSearchService() {
-    if (!globalSearchService) {
-        globalSearchService = new FaissSearchService();
-    }
-    if (!isGlobalServiceInitialized) {
-        await globalSearchService.loadEmbeddings();
-        await globalSearchService.loadIndex();
-        isGlobalServiceInitialized = true;
-    }
-    return globalSearchService;
-}
-const TOOL_HANDLER = async (args, extra) => {
-    const { query } = args;
-    try {
-        if (!query || query.trim().length === 0) {
-            return createToolTextContent(JSON.stringify({ error: "Query cannot be empty" }));
-        }
-        const searchService = await getSearchService();
-        const searchOptions = {
-            query: query.trim(),
-            limit: DEFAULT_SEARCH_LIMIT,
-            minSimilarity: DEFAULT_MIN_SIMILARITY,
-            urlPattern: undefined,
-        };
-        const { results, stats } = await searchService.search(searchOptions);
-        const searchResults = results.map(result => ({
-            sourceTitle: result.sourceTitle,
-            sourceUrl: result.sourceUrl,
-            chunkText: result.chunkText,
-        }));
-        logger.info('Semantic search results:', results);
-        // Log search statistics for debugging
-        logger.info('Semantic search stats:', {
-            searchTime: stats.searchTime,
-            totalVectors: stats.totalVectors,
-            resultsReturned: stats.resultsReturned,
-            resultsFiltered: stats.resultsFiltered,
-            query: query.trim()
-        });
-        return createToolTextContent(JSON.stringify(searchResults));
-    }
-    catch (error) {
-        return createToolTextContent(JSON.stringify({
-            error: `Search failed: ${error instanceof Error ? error.message : 'Unknown error'}`
-        }));
-    }
-};
-export async function createTool(server) {
-    try {
-        // Verify search service can be initialized and also save it into the cached variable
-        await getSearchService();
-        server.tool(TOOL_NAME, TOOL_DESCRIPTION, TOOL_ARGS, TOOL_HANDLER);
-    }
-    catch (error) {
-        logger.error('Failed to initialize semantic search tool:', error);
-        logger.error('Make sure you have the index and embeddings files in rhombus-node-mcp/data/embeddings/');
-        throw error;
-    }
-}

package/dist/tools/create-tool.js

@@ -1,30 +0,0 @@
-import { requireConfirmation } from "../utils/confirmation.js";
-import { handleCreateVideoWallRequest } from "../api/create-tool-api.js";
-import { TOOL_ARGS } from "../types/create-tool-types.js";
-const TOOL_NAME = "create-tool";
-const TOOL_DESCRIPTION = "Tool for creating many entity types such as video walls.";
-const TOOL_HANDLER = async (args, extra) => {
-    const { entityType, videoWallCreateOptions, confirmationId } = args;
-    const confirmation = requireConfirmation(confirmationId);
-    if (confirmation === true) {
-        switch (entityType) {
-            case "video-wall":
-                return await handleCreateVideoWallRequest(videoWallCreateOptions, extra._meta?.requestModifiers, extra.sessionId);
-            default:
-        }
-        return {
-            content: [
-                {
-                    type: "text",
-                    text: "",
-                },
-            ],
-        };
-    }
-    else {
-        return confirmation;
-    }
-};
-export function createTool(server) {
-    server.tool(TOOL_NAME, TOOL_DESCRIPTION, TOOL_ARGS, TOOL_HANDLER);
-}

package/dist/types/create-tool-types.js

@@ -1,8 +0,0 @@
-import { z } from "zod";
-import { CreateVideoWallOptions } from "../types.js";
-import { addConfirmationParams } from "../utils/confirmation.js";
-export const TOOL_ARGS = addConfirmationParams({
-    entityType: z.enum(["video-wall"]).describe("The entity type to create.  Example: video wall."),
-    videoWallCreateOptions: CreateVideoWallOptions,
-});
-const TOOL_ARGS_SCHEMA = z.object(TOOL_ARGS);