@golemui/gui-mcp 1.0.0-rc.3 → 1.0.0-rc.5

package/{lint → shared/lint}/reactive-expressions.d.ts

@@ -16,3 +16,11 @@ export type ExpressionFinding = {
  * We deliberately don't try to fully parse: too easy to get false positives, too little gain.
  */
 export declare function lintReactiveExpressions(formDefinition: unknown): ExpressionFinding[];
+/**
+ * Lint a single reactive expression string in isolation, against the same rules
+ * `lintReactiveExpressions` applies while walking a JSON form definition. This is
+ * the shared engine the DX path (`dx_check_code`) reuses: the JSON walker has the
+ * object tree, the DX linter has the AST — both funnel each `when` expression
+ * through here so the two surfaces can never drift.
+ */
+export declare function checkReactiveExpression(expression: string, path?: string): ExpressionFinding[];

package/shared/tool.d.ts

@@ -0,0 +1,49 @@
+/**
+ * The MCP tool wiring shared by both authoring paths.
+ *
+ * Each path (`json/`, `dx/`) and the shared surface export a `ToolEntry[]` that pairs an
+ * MCP tool descriptor with its handler. The server concatenates those arrays for both the
+ * `tools/list` response and name-based dispatch, so adding a tool is a one-line change in
+ * the owning module — there is no central switch to keep in sync.
+ */
+/**
+ * The shape of the exported `*_TOOL` descriptor objects. Kept intentionally loose
+ * (`inputSchema: unknown`, readonly fields) so the `as const` descriptors assign without
+ * readonly friction; the MCP client is what validates `arguments` against the real
+ * `inputSchema` before a call ever reaches us.
+ */
+export type ToolDescriptor = {
+    readonly name: string;
+    readonly description?: string;
+    readonly inputSchema: unknown;
+};
+/** One registered MCP tool: its descriptor (advertised to the client) and its handler. */
+export interface ToolEntry {
+    tool: ToolDescriptor;
+    run: (args: Record<string, unknown> | undefined) => unknown | Promise<unknown>;
+}
+/**
+ * Pair a tool descriptor with its handler. `args` arrives already shape-validated by the
+ * MCP client against `tool.inputSchema`, so this is the single trusted boundary where raw
+ * arguments are cast to the handler's input type — instead of an `as any` repeated at
+ * every dispatch arm.
+ *
+ * @example
+ * const jsonTools = [defineTool(JSON_VALIDATE_FORM_DEFINITION_TOOL, validateFormDefinition)];
+ */
+export declare function defineTool<Input, Output>(tool: ToolDescriptor, handler: (input: Input) => Output): ToolEntry;
+/** Wrap a successful tool result in the MCP text-content envelope. */
+export declare function ok(payload: unknown): {
+    content: {
+        type: "text";
+        text: string;
+    }[];
+};
+/** Wrap an error message in the MCP error envelope. */
+export declare function err(message: string): {
+    isError: boolean;
+    content: {
+        type: "text";
+        text: string;
+    }[];
+};

package/shared/tools.d.ts

@@ -0,0 +1,7 @@
+import { ToolEntry } from './tool';
+/**
+ * Cross-cutting reference tools that serve both authoring paths. `get_concept` explains
+ * behavior that spans widgets (conditional rendering, per-state props, the reactive
+ * scope), which a JSON author and a `gui.*` DX author both reach for.
+ */
+export declare const sharedTools: ToolEntry[];