release: v1.3.0 (synced from monorepo 26b5ad1e)

Author: Sterfive CI

package.json

@@ -1,6 +1,6 @@
 {
   "name": "node-opcua-modeler-mcp-server",
-  "version": "1.2.3",
+  "version": "1.3.0",
   "mcpName": "io.github.node-opcua/node-opcua-modeler-mcp-server",
   "description": "OPC UA Modeler MCP Server — exposes companion spec tools to AI agents",
   "type": "module",

server.json

@@ -3,7 +3,7 @@
   "name": "io.github.node-opcua/node-opcua-modeler-mcp-server",
   "title": "OPC UA Modeler",
   "description": "OPC UA companion spec types, namespace dependencies, and engineering units for AI agents",
-  "version": "1.2.3",
+  "version": "1.3.0",
   "websiteUrl": "https://opcua-modeler.sterfive.io",
   "repository": {
     "url": "https://github.com/node-opcua/node-opcua-modeler-mcp-server",
@@ -13,7 +13,7 @@
     {
       "registryType": "npm",
       "identifier": "node-opcua-modeler-mcp-server",
-      "version": "1.2.3",
+      "version": "1.3.0",
       "registryBaseUrl": "https://registry.npmjs.org",
       "runtimeHint": "npx",
       "transport": {

src/catalog.ts

@@ -149,6 +149,102 @@ export function searchTypes(query: string): (TypeSummary & { alias: string })[]
   return results;
 }
 
+// ── Reusable Block Discovery (interfaces & addins by capability) ─────────
+
+export interface ReusableBlockMatch {
+  /** Alias-prefixed type name, e.g. `di:IVendorNameplateType`. */
+  browseName: string;
+  alias: string;
+  kind: "interface" | "addin";
+  isAbstract: boolean;
+  /** True if this addin type declares a DefaultInstanceBrowseName (composable by default name). */
+  hasDefaultInstanceBrowseName: boolean;
+  /** Member browseNames that matched the query. */
+  matchedMembers: string[];
+  /** All member browseNames (components + properties + methods). */
+  members: string[];
+}
+
+function memberBrowseNames(d: TypeDetails): string[] {
+  return [...d.components.map((m) => m.browseName), ...d.properties.map((m) => m.browseName), ...d.methods];
+}
+
+/** Build the set of interface types (alias:browseName) via a subtypeOf → BaseInterfaceType fixpoint. */
+function buildInterfaceSet(): Set<string> {
+  const catalog = getCatalog();
+  const entries: { key: string; subtypeOf?: string }[] = [];
+  for (const [alias, details] of Object.entries(catalog.typeDetails)) {
+    for (const [bn, d] of Object.entries(details)) {
+      entries.push({ key: `${alias}:${bn}`, subtypeOf: d.subtypeOf });
+    }
+  }
+  const isInterface = new Set<string>();
+  let changed = true;
+  while (changed) {
+    changed = false;
+    for (const e of entries) {
+      if (isInterface.has(e.key)) continue;
+      if (e.subtypeOf === "ua:BaseInterfaceType" || (e.subtypeOf !== undefined && isInterface.has(e.subtypeOf))) {
+        isInterface.add(e.key);
+        changed = true;
+      }
+    }
+  }
+  return isInterface;
+}
+
+let _interfaceSet: Set<string> | null = null;
+
+/**
+ * Find reusable Interfaces / AddIns by capability — e.g. `find_reusable_block("SerialNumber")`
+ * returns the interfaces/addins that expose a matching member. Matches member browseNames,
+ * plus the block's own name/description. Prefer an existing block over redefining members.
+ */
+export function findReusableBlock(query: string): ReusableBlockMatch[] {
+  const catalog = getCatalog();
+  const q = query.toLowerCase();
+  if (!_interfaceSet) _interfaceSet = buildInterfaceSet();
+
+  const matches: ReusableBlockMatch[] = [];
+  for (const [alias, details] of Object.entries(catalog.typeDetails)) {
+    for (const [bn, d] of Object.entries(details)) {
+      const key = `${alias}:${bn}`;
+      const isInterface = _interfaceSet.has(key);
+      const hasDefaultName = d.properties.some((m) => /defaultinstancebrowsename/i.test(m.browseName));
+      // Only interfaces and addin-capable types are "reusable blocks".
+      if (!isInterface && !hasDefaultName) continue;
+
+      const members = memberBrowseNames(d);
+      const matchedMembers = members.filter((m) => m.toLowerCase().includes(q));
+      const nameMatch = bn.toLowerCase().includes(q) || (d.description?.toLowerCase().includes(q) ?? false);
+      if (matchedMembers.length === 0 && !nameMatch) continue;
+
+      matches.push({
+        browseName: key,
+        alias,
+        kind: isInterface ? "interface" : "addin",
+        isAbstract: d.isAbstract,
+        hasDefaultInstanceBrowseName: hasDefaultName,
+        matchedMembers,
+        members
+      });
+    }
+  }
+  // Rank: member match before name-only; interfaces (the canonical member
+  // definers) before addins; more matched members first; abstract addin bases
+  // after concrete composable ones.
+  matches.sort((a, b) => {
+    const am = a.matchedMembers.length > 0 ? 0 : 1;
+    const bm = b.matchedMembers.length > 0 ? 0 : 1;
+    if (am !== bm) return am - bm;
+    if (a.kind !== b.kind) return a.kind === "interface" ? -1 : 1;
+    if (a.kind === "addin" && a.isAbstract !== b.isAbstract) return a.isAbstract ? 1 : -1;
+    return b.matchedMembers.length - a.matchedMembers.length;
+  });
+  // Cap: this is a "point me at the right block" tool, not an exhaustive dump.
+  return matches.slice(0, 15);
+}
+
 // ── Engineering Unit Lookup ──────────────────────────────────────────────
 
 export interface UnitLookupResult {

src/server.ts

@@ -15,11 +15,19 @@
 
 import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
 import { z } from "zod";
-import { findEngineeringUnit, getTypeDetails, listNamespaces, listTypes, resolveDependencies, searchTypes } from "./catalog.js";
+import {
+  findEngineeringUnit,
+  findReusableBlock,
+  getTypeDetails,
+  listNamespaces,
+  listTypes,
+  resolveDependencies,
+  searchTypes
+} from "./catalog.js";
 import { cloudFetch, formatCloudError } from "./cloud.js";
 
 // Re-export for testing
-export { findEngineeringUnit, getTypeDetails, listNamespaces, listTypes, resolveDependencies, searchTypes };
+export { findEngineeringUnit, findReusableBlock, getTypeDetails, listNamespaces, listTypes, resolveDependencies, searchTypes };
 
 /** Tool name type */
 export type ToolName =
@@ -28,6 +36,7 @@ export type ToolName =
   | "list_types"
   | "get_type_details"
   | "search_types"
+  | "find_reusable_block"
   | "find_engineering_unit"
   | "opcua_model_validate"
   | "opcua_model_generate"
@@ -67,6 +76,9 @@ export async function handleToolCall(name: ToolName, args: Record<string, unknow
       case "search_types": {
         return { content: [{ type: "text" as const, text: JSON.stringify(searchTypes(args.query as string)) }] };
       }
+      case "find_reusable_block": {
+        return { content: [{ type: "text" as const, text: JSON.stringify(findReusableBlock(args.query as string)) }] };
+      }
       case "find_engineering_unit": {
         const result = findEngineeringUnit(String(args.query ?? ""));
         if (!result) {
@@ -193,6 +205,25 @@ export function createServer(): McpServer {
     }
   );
 
+  // ── 5b. find_reusable_block ───────────────────────────────────────────
+
+  server.tool(
+    "find_reusable_block",
+    "Find reusable Interfaces / AddIns by capability — pass a member name or keyword " +
+      '(e.g. "SerialNumber", "DeviceHealth", "Location") and get the standard blocks that ' +
+      "already expose it. PREFER applying/composing an existing block over redefining its " +
+      "members inline. Interfaces are applied with `interfaces:`; addins (types with a " +
+      "DefaultInstanceBrowseName) are composed with `addIns:`. A single property → use the " +
+      "Interface; a whole named sub-object → use the AddIn.",
+    { query: z.string().describe('Member name or capability keyword (e.g. "SerialNumber", "health", "calibration")') },
+    async ({ query }) => {
+      const results = findReusableBlock(query);
+      return {
+        content: [{ type: "text" as const, text: JSON.stringify(results) }]
+      };
+    }
+  );
+
   // ── 6. find_engineering_unit ──────────────────────────────────────────
 
   server.tool(