@tooluminati/forms 0.1.0

package/dist/index.cjs

@@ -0,0 +1,413 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/index.ts
+var index_exports = {};
+__export(index_exports, {
+  FormValidationError: () => FormValidationError,
+  createFormSubmitTool: () => createFormSubmitTool,
+  createFormValidationSummaryTool: () => createFormValidationSummaryTool,
+  createWebMcpFormTools: () => createWebMcpFormTools,
+  flattenReactHookFormErrors: () => flattenReactHookFormErrors,
+  formDataToObject: () => formDataToObject,
+  inferSchemaFromValue: () => inferSchemaFromValue,
+  useFormikWebMcpTool: () => useFormikWebMcpTool,
+  useNativeFormWebMcpTool: () => useNativeFormWebMcpTool,
+  useReactHookFormWebMcpTool: () => useReactHookFormWebMcpTool,
+  useTanStackFormWebMcpTool: () => useTanStackFormWebMcpTool,
+  useWebMcpFormTool: () => useWebMcpFormTool
+});
+module.exports = __toCommonJS(index_exports);
+
+// src/errors.ts
+var FormValidationError = class extends Error {
+  errors;
+  constructor(message, errors) {
+    super(message);
+    this.name = "FormValidationError";
+    this.errors = errors;
+  }
+};
+
+// src/useWebMcpFormTool.ts
+var import_react = require("react");
+var import_react2 = require("@tooluminati/react");
+
+// src/infer-schema.ts
+function inferSchemaFromValue(value) {
+  if (typeof value === "string") {
+    return { type: "string" };
+  }
+  if (typeof value === "number") {
+    return { type: "number" };
+  }
+  if (typeof value === "boolean") {
+    return { type: "boolean" };
+  }
+  if (value === null || value === void 0) {
+    return void 0;
+  }
+  if (Array.isArray(value)) {
+    if (value.length === 0) {
+      return void 0;
+    }
+    const items = inferSchemaFromValue(value[0]);
+    return items ? { type: "array", items } : void 0;
+  }
+  if (typeof value === "object") {
+    const properties = {};
+    const required = [];
+    for (const [key, childValue] of Object.entries(
+      value
+    )) {
+      const childSchema = inferSchemaFromValue(childValue);
+      if (!childSchema) {
+        return void 0;
+      }
+      properties[key] = childSchema;
+      if (childValue !== void 0) {
+        required.push(key);
+      }
+    }
+    return {
+      type: "object",
+      properties,
+      required,
+      additionalProperties: false
+    };
+  }
+  return void 0;
+}
+
+// src/create-form-tools.ts
+function formatFormErrors(errors, message) {
+  const lines = errors.map(
+    (error) => `${error.path ? `${error.path}: ` : ""}${error.message || error.kind}`
+  );
+  return [message, ...lines].filter(Boolean).join("\n");
+}
+function applyRedactResult(result, redactResult) {
+  if (!redactResult) {
+    return result;
+  }
+  return redactResult(result);
+}
+function createFormValidationSummaryTool(options) {
+  const schema = options.schema ?? inferSchemaFromValue(options.getValues());
+  return {
+    name: `${options.name}_validation_summary`,
+    description: "Returns form schema, validation messages, and submitting/validating state without submitting.",
+    inputSchema: {
+      type: "object",
+      properties: {},
+      additionalProperties: false
+    },
+    annotations: { readOnlyHint: true },
+    execute: () => {
+      const summary = {
+        name: options.name,
+        errors: options.getErrors?.() ?? [],
+        schema,
+        ...options.getSummary?.()
+      };
+      if (options.redactValues) {
+        return {
+          ...summary,
+          values: options.redactValues(options.getValues())
+        };
+      }
+      return summary;
+    }
+  };
+}
+function createFormSubmitTool(options) {
+  const schema = options.schema ?? inferSchemaFromValue(options.getValues());
+  if (!schema) {
+    throw new Error(
+      `Could not infer WebMCP schema for form "${options.name}". Provide an explicit schema or use concrete non-null defaults.`
+    );
+  }
+  return {
+    name: options.name,
+    description: options.description,
+    inputSchema: schema,
+    annotations: {
+      readOnlyHint: false,
+      ...options.annotations
+    },
+    validateArgs: options.validateArgs,
+    execute: async (rawArgs) => {
+      const values = options.validateArgs ? options.validateArgs(rawArgs) : rawArgs;
+      await options.setValues(values);
+      const result = await options.submit();
+      if (result.success) {
+        let output = result.message ?? "Form submitted successfully.";
+        if (result.data !== void 0) {
+          output = {
+            message: output,
+            data: options.redactValues ? options.redactValues(result.data) : result.data
+          };
+        }
+        return applyRedactResult(output, options.redactResult);
+      }
+      const errors = result.errors ?? options.getErrors?.() ?? [];
+      return applyRedactResult(
+        {
+          content: [
+            {
+              type: "text",
+              text: `Form submission failed:
+${formatFormErrors(
+                errors,
+                result.message
+              )}`
+            }
+          ],
+          isError: true
+        },
+        options.redactResult
+      );
+    }
+  };
+}
+function createWebMcpFormTools(options) {
+  const includeValidationSummary = options.includeValidationSummary ?? true;
+  const submitTool = createFormSubmitTool(options);
+  if (includeValidationSummary) {
+    return [
+      submitTool,
+      createFormValidationSummaryTool(options)
+    ];
+  }
+  return [submitTool];
+}
+
+// src/useWebMcpFormTool.ts
+function useWebMcpFormTool(options, deps = []) {
+  const schema = (0, import_react.useMemo)(
+    () => options.schema ?? inferSchemaFromValue(options.getValues()),
+    [options]
+  );
+  if (!schema) {
+    throw new Error(
+      `Could not infer WebMCP schema for form "${options.name}". Provide an explicit schema or use concrete non-null defaults.`
+    );
+  }
+  const tools = (0, import_react.useMemo)(
+    () => createWebMcpFormTools(options),
+    [options]
+  );
+  (0, import_react2.useWebMcpTools)(tools, deps, { source: "form" });
+}
+
+// src/formik.ts
+function flattenErrors(errors, prefix = "") {
+  if (!errors || typeof errors !== "object") {
+    return [];
+  }
+  return Object.entries(errors).flatMap(
+    ([key, value]) => {
+      const path = prefix ? `${prefix}.${key}` : key;
+      if (typeof value === "string") {
+        return [{ path, message: value }];
+      }
+      return flattenErrors(value, path);
+    }
+  );
+}
+function useFormikWebMcpTool({
+  formik,
+  ...options
+}) {
+  useWebMcpFormTool({
+    ...options,
+    getValues: () => formik.values,
+    setValues: (values) => formik.setValues(values),
+    getErrors: () => flattenErrors(formik.errors),
+    getSummary: () => ({
+      submitting: formik.isSubmitting,
+      validating: formik.isValidating,
+      touched: Boolean(formik.touched)
+    }),
+    submit: async () => {
+      const errors = await formik.validateForm();
+      const flattened = flattenErrors(errors);
+      if (flattened.length > 0) {
+        return { success: false, errors: flattened };
+      }
+      await formik.submitForm();
+      return { success: true };
+    }
+  });
+}
+
+// src/native-form.ts
+function formDataToObject(form) {
+  return Object.fromEntries(new FormData(form).entries());
+}
+function useNativeFormWebMcpTool(options) {
+  if (!options.schema) {
+    throw new Error("Native form WebMCP tools require an explicit schema.");
+  }
+  useWebMcpFormTool({
+    ...options,
+    getValues: () => {
+      const form = options.formRef.current;
+      return form ? formDataToObject(form) : {};
+    },
+    setValues: (values) => {
+      const form = options.formRef.current;
+      if (!form) {
+        return;
+      }
+      for (const [name, value] of Object.entries(values)) {
+        const field = form.elements.namedItem(name);
+        if (field && "value" in field) {
+          field.value = String(value ?? "");
+        }
+      }
+    },
+    getErrors: () => [],
+    submit: () => {
+      const form = options.formRef.current;
+      if (!form) {
+        return { success: false, message: "Form is not mounted." };
+      }
+      if (!form.checkValidity()) {
+        form.reportValidity();
+        return { success: false, message: "Native form validation failed." };
+      }
+      form.requestSubmit();
+      return { success: true, message: "Native form submitted." };
+    }
+  });
+}
+
+// src/react-hook-form.ts
+function flattenReactHookFormErrors(errors, prefix = "") {
+  if (!errors || typeof errors !== "object") {
+    return [];
+  }
+  return Object.entries(errors).flatMap(
+    ([key, value]) => {
+      const path = prefix ? `${prefix}.${key}` : key;
+      if (value?.message || value?.type) {
+        return [
+          {
+            path,
+            message: String(value.message ?? value.type),
+            kind: value.type ? String(value.type) : void 0
+          }
+        ];
+      }
+      return flattenReactHookFormErrors(value, path);
+    }
+  );
+}
+function useReactHookFormWebMcpTool({
+  form,
+  onValidSubmit,
+  ...options
+}) {
+  useWebMcpFormTool({
+    ...options,
+    getValues: () => form.getValues(),
+    setValues: async (values) => {
+      form.reset(values);
+      await form.trigger();
+    },
+    getErrors: () => flattenReactHookFormErrors(form.formState.errors),
+    getSummary: () => ({
+      submitting: form.formState.isSubmitting,
+      validating: form.formState.isValidating,
+      dirty: form.formState.isDirty,
+      touched: Boolean(form.formState.touchedFields)
+    }),
+    submit: async () => {
+      let valid = false;
+      let data;
+      await form.handleSubmit(
+        async (values) => {
+          valid = true;
+          data = await onValidSubmit(values);
+        },
+        async () => {
+          valid = false;
+        }
+      )();
+      if (valid) {
+        return { success: true, data };
+      }
+      return {
+        success: false,
+        errors: flattenReactHookFormErrors(form.formState.errors)
+      };
+    }
+  });
+}
+
+// src/tanstack-form.ts
+function flattenTanStackErrors(errors = []) {
+  return errors.map((error, index) => ({
+    path: typeof error === "object" && error && "path" in error ? String(error.path) : String(index),
+    message: typeof error === "object" && error && "message" in error ? String(error.message) : String(error)
+  }));
+}
+function useTanStackFormWebMcpTool({
+  form,
+  ...options
+}) {
+  useWebMcpFormTool({
+    ...options,
+    getValues: () => form.state.values,
+    setValues: (values) => {
+      for (const [field, value] of Object.entries(
+        values
+      )) {
+        form.setFieldValue?.(field, value);
+      }
+    },
+    getErrors: () => flattenTanStackErrors(form.state.errors),
+    getSummary: () => ({
+      submitting: form.state.isSubmitting,
+      validating: form.state.isValidating,
+      dirty: form.state.isDirty
+    }),
+    submit: async () => {
+      await form.handleSubmit();
+      const errors = flattenTanStackErrors(form.state.errors);
+      return errors.length > 0 ? { success: false, errors } : { success: true };
+    }
+  });
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  FormValidationError,
+  createFormSubmitTool,
+  createFormValidationSummaryTool,
+  createWebMcpFormTools,
+  flattenReactHookFormErrors,
+  formDataToObject,
+  inferSchemaFromValue,
+  useFormikWebMcpTool,
+  useNativeFormWebMcpTool,
+  useReactHookFormWebMcpTool,
+  useTanStackFormWebMcpTool,
+  useWebMcpFormTool
+});

package/dist/index.d.ts

@@ -0,0 +1,13 @@
+/**
+ * @experimental Tooluminati form adapters — public APIs may change.
+ */
+export * from './errors';
+export * from './formik';
+export * from './infer-schema';
+export * from './native-form';
+export * from './react-hook-form';
+export * from './tanstack-form';
+export * from './types';
+export * from './create-form-tools';
+export * from './useWebMcpFormTool';
+//# sourceMappingURL=index.d.ts.map

package/dist/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA;;GAEG;AACH,cAAc,UAAU,CAAC;AACzB,cAAc,UAAU,CAAC;AACzB,cAAc,gBAAgB,CAAC;AAC/B,cAAc,eAAe,CAAC;AAC9B,cAAc,mBAAmB,CAAC;AAClC,cAAc,iBAAiB,CAAC;AAChC,cAAc,SAAS,CAAC;AACxB,cAAc,qBAAqB,CAAC;AACpC,cAAc,qBAAqB,CAAC"}