formhaus 0.0.0-stage → 0.14.2

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 formhaus contributors
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -1,3 +1,36 @@
-# Temporary Holding Version
+# formhaus
 
-This version is a temporary placeholder for this package. An operational version to replace this has been submitted for review and is awaiting a staged release.
+Adds the [Formhaus](https://formhaus.dev) MCP server and agent instructions to the coding agents on your machine.
+
+```bash
+npx formhaus
+```
+
+Run it inside a project to also add the Cursor rule there. Requires Node 20 or later.
+
+## What it changes
+
+| Agent | Detected by | Change |
+|-------|-------------|--------|
+| Claude Code | `claude` on `PATH` | `claude mcp add --scope user formhaus -- npx -y @formhaus/mcp` and the `formhaus-create-form` skill in `~/.claude/skills` |
+| Codex | `~/.codex` or `codex` on `PATH` | `[mcp_servers.formhaus]` in `~/.codex/config.toml` |
+| Cursor | `~/.cursor` or `cursor` on `PATH` | `formhaus` in `~/.cursor/mcp.json`, and `.cursor/rules/formhaus.mdc` when run inside a project |
+| Claude Desktop | its config directory on macOS and Windows | `formhaus` in `claude_desktop_config.json` |
+
+Windsurf, Gemini CLI, OpenCode, VS Code and Claude Desktop on Linux are detected and listed with manual setup steps.
+
+Existing entries are kept. An existing `formhaus` server with another command or args is reported and left unchanged, and a project `.mcp.json` never counts as set up. Before the first change to a file, the original is saved as `<file>.bak`. Formhaus does not write to a file that is a symbolic link, or through a linked directory inside the project. Running it again changes nothing. If the Formhaus Claude Code plugin is installed, Claude Code is left as is.
+
+## Options
+
+```
+npx formhaus [setup] [options]
+
+  --dry-run      Show the planned changes and write nothing
+  -h, --help     Show help
+  -v, --version  Show the version
+```
+
+The exit code is 0 when every agent is set up, including when nothing changed, and 1 when a step fails.
+
+[MCP server guide](https://formhaus.dev/guide/mcp) · MIT

package/dist/cli.js

@@ -0,0 +1,1223 @@
+#!/usr/bin/env node
+import { homedir } from 'os';
+import { parseArgs, isDeepStrictEqual } from 'util';
+import { existsSync, statSync, accessSync, constants, readFileSync, mkdirSync, copyFileSync, rmSync, writeFileSync, chmodSync, renameSync, lstatSync } from 'fs';
+import { join, isAbsolute, sep, dirname, relative, resolve } from 'path';
+import { spawnSync } from 'child_process';
+
+// package.json
+var version = "0.14.2";
+
+// ../../.cursor/rules/formhaus.mdc
+var formhaus_default = '---\ndescription: Formhaus form definitions. Use when creating, editing or reviewing a Formhaus JSON form definition, or code that passes one to FormEngine or FormRenderer.\nalwaysApply: false\n---\n\n# Formhaus form definitions\n\nA Formhaus form is a JSON definition rendered by `@formhaus/core` with `@formhaus/react` or `@formhaus/vue`. One definition drives the web form and the Figma plugin.\n\n- Start each definition file with `"$schema": "https://formhaus.dev/schema/form-definition.json"`.\n- Required keys: `id` (kebab-case), `title`, `submit: { "label": "..." }`.\n- Use `fields` for a single page or `steps` for a multi-step form, never both.\n- Field `key` values are camelCase and unique across all steps.\n- `show` and `showAny` conditions reference existing field keys and use `eq`, `neq`, `in`, `notIn` or `notEmpty`.\n- Step `routes` only point to later steps. `to: null` ends the form without auto-submission.\n\n## Checking definitions\n\nWhen the `formhaus` MCP server is available (`npx -y @formhaus/mcp`):\n\n- Call `capabilities` for the current field types, validation rules and step semantics.\n- Call `example_definitions` for working examples.\n- Call `validate_definition` after every change and fix all `errors` before finishing.\n- Call `simulate_path` with sample answers to check branching steps and conditions.\n\nReference: https://formhaus.dev/api/definition.html\n';
+
+// ../../plugins/formhaus/skills/formhaus-create-form/SKILL.md
+var SKILL_default = '---\nname: formhaus-create-form\ndescription: |\n  Generate @formhaus/core form definitions from any input: text description,\n  CSV/table, or screenshot of a form. Interactive step/condition builder.\n  Output pastes directly into the Formhaus Figma plugin or FormRenderer.\n  Use when: "generate form", "form definition", "form JSON", "create a form",\n  "formhaus", or when user describes form fields in any format.\nallowed-tools:\n  - Read\n  - Write\n  - Glob\n  - Grep\n  - AskUserQuestion\n  - Agent\n  - mcp__plugin_formhaus_formhaus__validate_definition\n  - mcp__plugin_formhaus_formhaus__simulate_path\n  - mcp__plugin_formhaus_formhaus__capabilities\n  - mcp__plugin_formhaus_formhaus__example_definitions\n  - mcp__plugin_formhaus_formhaus__publish_form\n  - mcp__plugin_formhaus_formhaus__list_forms\n  - mcp__formhaus__validate_definition\n  - mcp__formhaus__simulate_path\n  - mcp__formhaus__capabilities\n  - mcp__formhaus__example_definitions\n  - mcp__formhaus__publish_form\n  - mcp__formhaus__list_forms\n  - Edit\n  - Bash\n---\n\n# Form Definition Generator\n\nYou generate valid `@formhaus/core` form definitions from any input.\nThe output is ready to paste into the Formhaus Figma plugin or use with FormRenderer.\nThe formhaus repo does not need to be cloned. The JSON Schema is published at\n`https://formhaus.dev/schema/form-definition.json`.\n\n## Formhaus MCP tools\n\nCheck whether the `formhaus` MCP server tools are available (`validate_definition`,\n`simulate_path`, `capabilities`, `example_definitions`, `publish_form`). The Formhaus Claude Code plugin\nstarts the server. Without the plugin, it is added with\n`claude mcp add formhaus -- npx -y @formhaus/mcp`.\n\n- `capabilities` returns the current field types, validation rules, condition operators\n  and step semantics. Prefer it over the reference below when they differ.\n- `example_definitions` lists bundled example definitions and returns one by `id`.\n- `validate_definition` checks a definition against the JSON Schema and the engine.\n- `simulate_path` walks a multi-step definition with sample answers and reports the step path.\n- `publish_form` publishes a definition to Formhaus Cloud and returns a live endpoint, a hosted page URL, an embed snippet and a React snippet.\n\nIf the tools are not available, validate by hand against the types below and tell the\nuser that `@formhaus/mcp` can check the result.\n\n## Types Reference\n\nThese are the exact TypeScript types. Your output MUST conform to them.\n\n```typescript\ninterface FormDefinition {\n  id: string;           // kebab-case identifier\n  title: string;        // human-readable form title\n  description?: string; // short intro under the title, up to 1000 characters\n  submit: FormAction;   // submit button config (required)\n  cancel?: FormAction;  // cancel button (optional)\n  fields?: FormField[]; // single-step form\n  steps?: FormStep[];   // multi-step form (use steps OR fields, not both)\n}\n\ninterface FormStep {\n  id: string;\n  title: string;\n  description?: string;\n  fields: FormField[];\n  show?: ShowCondition[];    // step visible when ALL conditions true\n  showAny?: ShowCondition[]; // step visible when ANY condition true\n  routes?: StepRoute[];      // ordered forward destinations\n  next?: FormAction | false; // custom "next" or false to hide it\n  back?: FormAction | false; // custom "back" or false to hide it\n  skip?: FormAction;         // Skip button: resets the step, moves on without validation\n}\n\ninterface StepRoute {\n  to: string | null;         // later step id, or terminal without auto-submission\n  show?: ShowCondition[];\n  showAny?: ShowCondition[];\n}\n\ninterface FormField {\n  key: string;                // camelCase field identifier\n  type: FieldType;\n  label: string;\n  placeholder?: string;\n  helperText?: string;\n  defaultValue?: unknown;\n  autoAdvance?: boolean;     // explicit activation advances; built-in radio supports it\n  show?: ShowCondition[];     // field visible when ALL conditions true\n  showAny?: ShowCondition[];  // field visible when ANY condition true\n  validation?: FieldValidation;\n  options?: FieldOption[];    // for select, multiselect, radio\n  layout?: \'stack\' | \'inline\'; // radio/multiselect; inline only for a few short options\n  optionsFrom?: string;       // dynamic options loaded at runtime\n  optionsDependsOn?: string[];\n  accept?: string;            // for file type: "image/*", ".pdf"\n  rows?: number;              // for textarea\n  mask?: string;              // input mask\n  inputMode?: \'text\' | \'numeric\' | \'decimal\' | \'tel\' | \'email\' | \'url\' | \'search\';\n}\n\ntype FieldType =\n  | \'text\' | \'email\' | \'phone\' | \'number\' | \'password\'\n  | \'select\' | \'autocomplete\' | \'multiselect\'\n  | \'checkbox\' | \'radio\' | \'switch\'\n  | \'file\' | \'date\' | \'datetime\' | \'time\' | \'textarea\' | \'hidden\';\n\ninterface ShowCondition {\n  field: string;                        // references another field\'s key\n  eq?: string | number | boolean;       // equals\n  neq?: string | number | boolean;      // not equals\n  in?: (string | number)[];             // one of\n  notIn?: (string | number)[];          // not one of\n  notEmpty?: boolean;                   // has a value\n}\n\ninterface FieldValidation {\n  required?: boolean | string;  // true or custom message\n  minLength?: number;\n  minLengthMessage?: string;\n  maxLength?: number;\n  maxLengthMessage?: string;\n  min?: number;\n  minMessage?: string;\n  max?: number;\n  maxMessage?: string;\n  pattern?: string;             // regex\n  patternMessage?: string;\n  matchField?: string;          // must match another field (e.g. confirmPassword)\n  matchFieldMessage?: string;\n  validator?: string;           // custom validator name\n}\n\ninterface FieldOption { value: string; label: string; }\ninterface FormAction {\n  label: string;\n  variant?: \'primary\' | \'secondary\' | \'text\';\n  action?: string;\n  disabled?: ShowCondition[];\n}\n```\n\n## Workflow\n\n### Step 1: Detect input format\n\nLook at the user\'s input and classify:\n\n- **Text description**: "Registration form with name, email, password"\n- **CSV/table**: structured data with columns like key, type, label, required\n- **Screenshot**: user provides a path to an image file or says "look at this screenshot"\n- **Existing definition**: user references a bundled example (`example_definitions`)\n\n### Step 2: Extract fields\n\nFrom the input, extract a flat list of fields with: key, type, label, and any\nobvious validation (required, email format, etc).\n\n**Type inference rules:**\n- Email addresses \u2192 `email`\n- Phone numbers \u2192 `phone`\n- Passwords, PINs \u2192 `password`\n- "Agree to terms", "Subscribe" \u2192 `checkbox`\n- "Account type", "Gender" with 2-4 options \u2192 `radio`\n- Dropdowns, "Select..." with 5+ options \u2192 `select`\n- Searchable dropdowns, typeahead \u2192 `autocomplete`\n- Country, city, currency \u2192 `select`\n- Long text, "Description", "Notes", "Bio" \u2192 `textarea`\n- Dates, birthdays, "When" \u2192 `date`\n- Date and time together \u2192 `datetime`\n- Time of day only, "Start time", "Opening hours" \u2192 `time`\n- Tracking values the user never sees, "Source", "Campaign", "Referral code from the link" \u2192 `hidden`\n- File upload, "Attach", "Upload" \u2192 `file`\n- Toggle, "Enable/Disable", notifications \u2192 `switch`\n- Numbers, amounts, quantities \u2192 `number`\n- Everything else \u2192 `text`\n\n### Step 3: Interactive refinement\n\nUse AskUserQuestion for each decision point. ONE question at a time.\n\n**3a: Steps**\n\nIf the form has 5+ fields, ask:\n\n> "This form has N fields. Should it be a single page or split into steps?\n> If steps, describe how to group them (e.g. \'Personal info, Address, Payment\')."\n\nOptions:\n- A) Single step (all fields on one page)\n- B) Multi-step (I\'ll describe the groups)\n- C) Auto-group (you decide based on field types)\n\nIf C: group by semantic similarity (personal info, address, account, payment, etc.).\n\n**3b: Conditions**\n\nIf any field logically depends on another (e.g. "Bank name" only makes sense\nwhen payment method is "bank"), ask:\n\n> "I noticed [field X] probably only shows when [field Y] = [value].\n> Should I add show conditions?"\n\nOptions:\n- A) Yes, add the conditions you suggested\n- B) No conditions, show everything always\n- C) Let me specify which fields depend on what\n\n**3c: Validation**\n\nFor each field, infer validation:\n- Fields marked "required" or with * \u2192 `required: true`\n- Email fields \u2192 pattern for email format\n- Password fields \u2192 minLength: 8\n- Phone fields \u2192 inputMode: \'tel\'\n- Number fields \u2192 inputMode: \'numeric\'\n\nAsk only if there\'s ambiguity: "Should [field] be required?"\n\n### Step 4: Generate JSON\n\nOutput the complete form definition JSON. Follow these rules:\n\n1. `id` is kebab-case derived from the title\n2. `key` for each field is camelCase\n3. Every form MUST have `submit: { label: "..." }`\n4. Use `fields` for single-step, `steps` for multi-step\n5. Only include optional properties when they add value (no empty strings, no `required: false`)\n6. Options for select/radio must have both `value` and `label`\n\nPut `"$schema": "https://formhaus.dev/schema/form-definition.json"` as the first key\nso editors validate and autocomplete the file.\n\n### Step 5: Validate\n\nIf the MCP tools are available:\n\n1. Call `validate_definition` with the definition. Fix every entry in `errors` and\n   re-run until `errors` is empty. Review `warnings` and fix the ones that are real mistakes.\n2. For multi-step definitions with conditions or routes, call `simulate_path` with answers\n   that take each branch and check that the path matches the user\'s intent.\n\n### Step 6: Present and confirm\n\nShow the generated JSON in a code block. Ask:\n\n> "Here\'s your form definition. You can paste this directly into the\n> Formhaus Figma plugin or use with FormRenderer."\n\nOptions:\n- A) Looks good, copy and done\n- B) Make changes (specify what)\n- C) Publish it and get a live endpoint\n\nIf B: apply changes and re-present\n\n### Step 7: Publish and wire into the project\n\nOnly when the user chose C, or asked for a working form, a hosted form or an endpoint.\nRequires the `publish_form` tool and a definition that passed `validate_definition`.\n\n1. Call `publish_form` with the definition. Hosted forms do not support `password`, `file`,\n   `autocomplete`, `optionsFrom` and custom field types. If the tool reports an error, fix every\n   listed path and call it again.\n2. Tell the user the `hosted_url` and `endpoint`. Without an API key the form is unclaimed\n   (7 days, 100 submissions): give them the `claim_url` from the result.\n3. Detect the project: React or Vue in `package.json`, or plain HTML. Install the matching\n   package (`@formhaus/react` or `@formhaus/vue`, plus `@formhaus/core` for `style.css`) with\n   the project\'s package manager.\n4. Add the `react_snippet` from the result where the user wants the form. It imports\n   `FormhausForm` from `@formhaus/react/cloud`. For Vue use `FormhausForm` from\n   `@formhaus/vue/cloud` with the same `id`. For plain HTML use `embed_snippet`.\n5. Publishing again with the same `form_id` ships a new version at the same endpoint, so\n   later edits to the definition do not change the project code.\n\n## Example Definitions\n\nCall `example_definitions` to list the bundled examples and fetch one by `id` when you\nneed to verify a pattern or show the user an example. They cover common field types,\nvalidation, show conditions, linear steps, and branching steps with routes.\n\n## Rules\n\n- NEVER call `publish_form` unless the user asked for a hosted form or Formhaus Cloud. If the project has its own backend, render with `FormRenderer` and submit to that backend.\n- NEVER output invalid JSON. Validate before presenting, with `validate_definition` when available.\n- NEVER invent field types not in the FieldType union.\n- NEVER use `fields` AND `steps` in the same definition. Pick one.\n- Keys must be unique within a definition (across all steps).\n- ShowCondition.field must reference an existing field key.\n- For multi-step: each step needs `id`, `title`, and `fields`.\n- Submit label should match the form\'s purpose ("Submit", "Create transfer", "Register", etc.).\n';
+
+// src/context.ts
+var SetupError = class extends Error {
+};
+var SERVER_NAME = "formhaus";
+var SERVER_PACKAGE = "@formhaus/mcp";
+var SERVER = { command: "npx", args: ["-y", SERVER_PACKAGE] };
+var GUIDE_URL = "https://formhaus.dev/guide/mcp";
+function isOurServer(command2, args) {
+  return command2 === SERVER.command && Array.isArray(args) && args.length === SERVER.args.length && args.every((arg, index) => arg === SERVER.args[index]);
+}
+function readText(file) {
+  return existsSync(file) ? readFileSync(file, "utf8") : void 0;
+}
+function isDirectory(path) {
+  return existsSync(path) && statSync(path).isDirectory();
+}
+function refuseSymlink(ctx, path) {
+  if (lstatSync(path, { throwIfNoEntry: false })?.isSymbolicLink()) {
+    throw new SetupError(`${display(ctx, path)} is a symbolic link. Formhaus does not write through links. Edit the file by hand.`);
+  }
+}
+function isInside(parent, path) {
+  const between = relative(parent, path);
+  return between !== "" && !between.startsWith("..") && !isAbsolute(between);
+}
+function refuseLinkedDirectories(ctx, root, file) {
+  if (!isInside(root, file)) throw new SetupError(`${display(ctx, file)} is outside ${display(ctx, root)}. Edit the file by hand.`);
+  const parts = relative(root, dirname(file)).split(sep).filter(Boolean);
+  for (let index = 1; index <= parts.length; index++) refuseSymlink(ctx, resolve(root, ...parts.slice(0, index)));
+}
+function writeText(ctx, file, text, project) {
+  const backup = `${file}.bak`;
+  const temporary = `${file}.tmp`;
+  if (project !== void 0) refuseLinkedDirectories(ctx, project, file);
+  for (const path of [file, backup, temporary]) refuseSymlink(ctx, path);
+  if (ctx.dryRun) return;
+  mkdirSync(dirname(file), { recursive: true });
+  if (existsSync(file) && !existsSync(backup)) copyFileSync(file, backup, constants.COPYFILE_EXCL);
+  const mode = statSync(file, { throwIfNoEntry: false })?.mode;
+  rmSync(temporary, { force: true });
+  writeFileSync(temporary, text, { flag: "wx", mode: mode === void 0 ? void 0 : mode & 384 });
+  if (mode !== void 0) chmodSync(temporary, mode & 4095);
+  renameSync(temporary, file);
+}
+function writeIfChanged(ctx, file, text, project) {
+  const current = readText(file);
+  if (current === text) return "present";
+  writeText(ctx, file, text, project);
+  return current === void 0 ? "added" : "updated";
+}
+function display(ctx, path) {
+  return path.startsWith(ctx.home + sep) ? `~${path.slice(ctx.home.length)}` : path;
+}
+function step(ctx, agent, item, where, apply) {
+  const target = display(ctx, where);
+  const firstBackup = existsSync(where) && !existsSync(`${where}.bak`);
+  try {
+    const state = apply();
+    const backedUp = firstBackup && !ctx.dryRun && (state === "added" || state === "updated");
+    return { agent, item, where: backedUp ? `${target} (backup: ${target}.bak)` : target, state };
+  } catch (error) {
+    return { agent, item, where: target, state: "failed", error: error instanceof Error ? error.message : String(error) };
+  }
+}
+
+// src/json-config.ts
+function isObject(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function readJsonObject(ctx, file) {
+  const text = readText(file);
+  if (text === void 0 || text.trim() === "") return void 0;
+  let parsed;
+  try {
+    parsed = JSON.parse(text);
+  } catch {
+    throw new SetupError(`${display(ctx, file)} is not valid JSON. Fix it and run again. The file was not changed.`);
+  }
+  if (!isObject(parsed)) throw new SetupError(`${display(ctx, file)} must contain a JSON object. The file was not changed.`);
+  return parsed;
+}
+function jsonServerState(config) {
+  const servers = config?.mcpServers;
+  if (!isObject(servers) || !(SERVER_NAME in servers)) return "missing";
+  const entry = servers[SERVER_NAME];
+  return isObject(entry) && isOurServer(entry.command, entry.args) ? "present" : "different";
+}
+function addJsonServer(ctx, file) {
+  const config = readJsonObject(ctx, file) ?? {};
+  const servers = config.mcpServers ?? {};
+  if (!isObject(servers)) throw new SetupError(`"mcpServers" in ${display(ctx, file)} is not an object. The file was not changed.`);
+  const existing = jsonServerState({ mcpServers: servers });
+  if (existing !== "missing") return existing;
+  const next = { ...config, mcpServers: { ...servers, [SERVER_NAME]: SERVER } };
+  writeText(ctx, file, `${JSON.stringify(next, null, 2)}
+`);
+  return "added";
+}
+function isExecutable(file) {
+  try {
+    accessSync(file, constants.X_OK);
+    return statSync(file).isFile();
+  } catch {
+    return false;
+  }
+}
+function findOnPath(ctx, name) {
+  const windows = ctx.platform === "win32";
+  const extensions = windows ? (ctx.env.PATHEXT || ".EXE;.CMD;.BAT").split(";").filter(Boolean) : [""];
+  for (const directory of (ctx.env.PATH ?? "").split(windows ? ";" : ":")) {
+    if (!isAbsolute(directory)) continue;
+    for (const extension of extensions) {
+      const candidate = join(directory, name + extension.toLowerCase());
+      if (isExecutable(candidate)) return candidate;
+    }
+  }
+  return void 0;
+}
+function command(ctx, executable, args) {
+  if (ctx.platform !== "win32" || !/\.(cmd|bat)$/i.test(executable)) return { file: executable, args, verbatim: false };
+  const shell = ctx.env.ComSpec || join(ctx.env.SystemRoot || "C:\\Windows", "System32", "cmd.exe");
+  return { file: shell, args: ["/d", "/s", "/c", `""${executable}" ${args.join(" ")}"`], verbatim: true };
+}
+
+// src/claude-code.ts
+var NAME = "Claude Code";
+var PLUGIN_PREFIX = `${SERVER_NAME}@`;
+var CLAUDE_ADD_ARGS = ["mcp", "add", "--scope", "user", SERVER_NAME, "--", SERVER.command, ...SERVER.args];
+function configDir(ctx) {
+  return ctx.env.CLAUDE_CONFIG_DIR || join(ctx.home, ".claude");
+}
+function enabledPlugins(ctx) {
+  try {
+    const enabled = readJsonObject(ctx, join(configDir(ctx), "settings.json"))?.enabledPlugins;
+    return typeof enabled === "object" && enabled !== null ? enabled : {};
+  } catch {
+    return {};
+  }
+}
+function installedForUser(installs) {
+  return Array.isArray(installs) && installs.some((install) => typeof install === "object" && install !== null && (install.scope ?? "user") === "user");
+}
+function hasPlugin(ctx) {
+  const plugins = readJsonObject(ctx, join(configDir(ctx), "plugins", "installed_plugins.json"))?.plugins;
+  if (typeof plugins !== "object" || plugins === null) return false;
+  const enabled = enabledPlugins(ctx);
+  return Object.entries(plugins).some(
+    ([id, installs]) => id.startsWith(PLUGIN_PREFIX) && installedForUser(installs) && enabled[id] === true
+  );
+}
+function userServer(ctx) {
+  const file = ctx.env.CLAUDE_CONFIG_DIR ? join(ctx.env.CLAUDE_CONFIG_DIR, ".claude.json") : join(ctx.home, ".claude.json");
+  return jsonServerState(readJsonObject(ctx, file));
+}
+function projectWarning(ctx) {
+  const file = join(ctx.cwd, ".mcp.json");
+  try {
+    if (jsonServerState(readJsonObject(ctx, file)) !== "different") return [];
+  } catch {
+    return [];
+  }
+  return [{ agent: NAME, item: "project MCP server", where: display(ctx, file), state: "different" }];
+}
+function addServer(ctx, claude) {
+  if (hasPlugin(ctx)) return "present";
+  const existing = userServer(ctx);
+  if (existing !== "missing") return existing;
+  if (ctx.dryRun) return "added";
+  const { file, args, verbatim } = command(ctx, claude, CLAUDE_ADD_ARGS);
+  const result = spawnSync(file, args, { encoding: "utf8", env: ctx.env, windowsVerbatimArguments: verbatim });
+  if (result.status !== 0) {
+    const output = `${result.stderr ?? ""}${result.stdout ?? ""}`.trim() || result.error?.message || `exit code ${result.status}`;
+    throw new Error(`claude ${CLAUDE_ADD_ARGS.join(" ")} failed: ${output}`);
+  }
+  return "added";
+}
+var claudeCode = {
+  name: NAME,
+  detect: (ctx) => findOnPath(ctx, "claude") !== void 0,
+  apply(ctx) {
+    const claude = findOnPath(ctx, "claude");
+    const skill = join(configDir(ctx), "skills", "formhaus-create-form", "SKILL.md");
+    return [
+      step(ctx, NAME, "MCP server", `claude mcp add --scope user ${SERVER_NAME}`, () => addServer(ctx, claude)),
+      step(
+        ctx,
+        NAME,
+        "formhaus-create-form skill",
+        skill,
+        () => hasPlugin(ctx) ? "present" : writeIfChanged(ctx, skill, SKILL_default)
+      ),
+      ...projectWarning(ctx)
+    ];
+  }
+};
+
+// ../../node_modules/.pnpm/smol-toml@1.9.0/node_modules/smol-toml/dist/error.js
+function getLineColFromPtr(string, ptr) {
+  let lines = string.slice(0, ptr).split(/\r?\n/);
+  return [lines.length, lines.pop().length + 1];
+}
+function makeCodeBlock(string, line, column) {
+  let lines = string.split(/\r?\n/);
+  let codeblock = "";
+  let numberLen = (Math.log10(line + 1) | 0) + 1;
+  for (let i = line - 1; i <= line + 1; i++) {
+    let l = lines[i - 1];
+    if (!l)
+      continue;
+    codeblock += i.toString().padEnd(numberLen, " ");
+    codeblock += ":  ";
+    codeblock += l;
+    codeblock += "\n";
+    if (i === line) {
+      codeblock += " ".repeat(numberLen + column + 2);
+      codeblock += "^\n";
+    }
+  }
+  return codeblock;
+}
+var TomlError = class _TomlError extends Error {
+  line;
+  column;
+  codeblock;
+  constructor(message, options) {
+    const [line, column] = getLineColFromPtr(options.toml, options.ptr);
+    const codeblock = makeCodeBlock(options.toml, line, column);
+    super(`Invalid TOML document: ${message}
+
+${codeblock}`, options);
+    this.line = line;
+    this.column = column;
+    this.codeblock = codeblock;
+  }
+  /** @internal */
+  static x(message, ctx, ptr) {
+    throw new _TomlError(message, { toml: ctx.s, ptr: ptr ?? ctx.p });
+  }
+};
+
+// ../../node_modules/.pnpm/smol-toml@1.9.0/node_modules/smol-toml/dist/primitive.js
+function parseString(ctx) {
+  let startPtr = ctx.p;
+  let c = ctx.s.charCodeAt(ctx.p++);
+  let first = c;
+  let isLiteral = c === 39;
+  let isMultiline = c === ctx.s.charCodeAt(ctx.p) && c === ctx.s.charCodeAt(ctx.p + 1);
+  if (isMultiline) {
+    if ((c = ctx.s.charCodeAt(ctx.p += 2)) === 10)
+      ctx.p++;
+    else if (c === 13 && ctx.s.charCodeAt(ctx.p + 1) === 10)
+      ctx.p += 2;
+  }
+  let parsed = "";
+  let sliceStart = ctx.p;
+  let state = 0;
+  for (; ctx.p < ctx.s.length; ctx.p++) {
+    c = ctx.s.charCodeAt(ctx.p);
+    if (isMultiline && (c === 10 || c === 13 && ctx.s.charCodeAt(ctx.p + 1) === 10)) {
+      state = state && 3;
+    } else if (c < 32 && c !== 9 || c === 127) {
+      TomlError.x("control characters are not allowed in strings", ctx);
+    } else if ((!state || state === 3) && c === first && (!isMultiline || ctx.s.charCodeAt(ctx.p + 1) === first && ctx.s.charCodeAt(ctx.p + 2) === first)) {
+      if (isMultiline) {
+        if (ctx.s.charCodeAt(ctx.p + 3) === first)
+          ctx.p++;
+        if (ctx.s.charCodeAt(ctx.p + 3) === first)
+          ctx.p++;
+      }
+      if (!state) {
+        let s = ctx.s.slice(sliceStart, ctx.p);
+        parsed = parsed ? parsed + s : s;
+      }
+      ctx.p += isMultiline ? 3 : 1;
+      return parsed;
+    } else if (!state) {
+      if (!isLiteral && c === 92) {
+        parsed += ctx.s.slice(sliceStart, sliceStart = ctx.p);
+        state = 1;
+      }
+    } else if (state === 1) {
+      if (c === 120 || c === 117 || c === 85) {
+        let errPtr = ctx.p++ - 1;
+        let value = 0;
+        let len = c === 120 ? 2 : c === 117 ? 4 : 8;
+        for (let j = 0; j < len; j++, ctx.p++) {
+          let hex = ctx.s.charCodeAt(ctx.p);
+          let digit = (
+            /* 0-9 */
+            hex >= 48 && hex <= 57 ? hex - 48 : (
+              /* A-F */
+              hex >= 65 && hex <= 70 ? hex - 65 + 10 : (
+                /* a-f */
+                hex >= 97 && hex <= 102 ? hex - 97 + 10 : -1
+              )
+            )
+          );
+          if (digit < 0)
+            TomlError.x("invalid non-hex character in unicode escape", ctx);
+          value = value << 4 | digit;
+        }
+        if (value < 0 || value > 1114111 || value >= 55296 && value <= 57343) {
+          TomlError.x("invalid unicode escape", ctx, errPtr);
+        }
+        parsed += String.fromCodePoint(value);
+        sliceStart = ctx.p--;
+        state = 0;
+      } else if (isMultiline && (c === 32 || c === 9)) {
+        state = 2;
+      } else {
+        if (c === 98)
+          parsed += "\b";
+        else if (c === 116)
+          parsed += "	";
+        else if (c === 110)
+          parsed += "\n";
+        else if (c === 102)
+          parsed += "\f";
+        else if (c === 114)
+          parsed += "\r";
+        else if (c === 101)
+          parsed += "\x1B";
+        else if (c === 34)
+          parsed += '"';
+        else if (c === 92)
+          parsed += "\\";
+        else
+          TomlError.x("unrecognised escape sequence", ctx);
+        sliceStart = ctx.p + 1;
+        state = 0;
+      }
+    } else if (c !== 32 && c !== 9) {
+      if (state === 2)
+        TomlError.x("invalid escape: only line-ending whitespace may be escaped", ctx, sliceStart);
+      state = !isLiteral && c === 92 ? 1 : 0;
+      sliceStart = ctx.p;
+    }
+  }
+  TomlError.x("unfinished string", ctx, startPtr);
+}
+
+// ../../node_modules/.pnpm/smol-toml@1.9.0/node_modules/smol-toml/dist/date.js
+var DATE_TIME_RE = /^(\d{4}-\d{2}-\d{2})?[Tt ]?(?:(\d{2}):\d{2}(?::\d{2}(?:\.\d+)?)?)?(Z|z|[-+]\d{2}:\d{2})?$/i;
+var TomlDate = class _TomlDate extends Date {
+  #hasDate = false;
+  #hasTime = false;
+  #offset = null;
+  constructor(date, fasttype, unsafeDelim) {
+    let hasDate = true;
+    let hasTime = true;
+    let offset = "Z";
+    let c;
+    if (typeof date === "string") {
+      if (fasttype)
+        prep: {
+          if (fasttype < 3) {
+            if (+date.slice(11, 13) > 23) {
+              date = "";
+              break prep;
+            }
+            if (fasttype === 2) {
+              offset = null;
+              date += "Z";
+            } else if ((c = date.charCodeAt(date.length - 1)) !== 90 && c !== 122) {
+              offset = date.slice(date.length - 6);
+            }
+            if (unsafeDelim)
+              date = date.slice(0, 10) + "T" + date.slice(11);
+          } else if (fasttype === 4) {
+            date = +date.slice(0, 2) > 23 ? "" : `0000-01-01T${date}Z`;
+          }
+          hasDate = fasttype !== 4;
+          hasTime = fasttype !== 3;
+        }
+      else {
+        let match = date.match(DATE_TIME_RE);
+        if (match) {
+          if (!match[1]) {
+            hasDate = false;
+            date = `0000-01-01T${date}`;
+          }
+          hasTime = !!match[2];
+          hasTime && date[10] === " " && (date = date.replace(" ", "T"));
+          if (match[2] && +match[2] > 23) {
+            date = "";
+          } else {
+            offset = match[3] || null;
+            if (!offset && hasTime)
+              date += "Z";
+          }
+        } else {
+          date = "";
+        }
+      }
+    }
+    super(date);
+    if (!isNaN(this.getTime())) {
+      this.#hasDate = hasDate;
+      this.#hasTime = hasTime;
+      this.#offset = offset;
+    }
+  }
+  isDateTime() {
+    return this.#hasDate && this.#hasTime;
+  }
+  isLocal() {
+    return !this.#hasDate || !this.#hasTime || !this.#offset;
+  }
+  isDate() {
+    return this.#hasDate && !this.#hasTime;
+  }
+  isTime() {
+    return this.#hasTime && !this.#hasDate;
+  }
+  isValid() {
+    return this.#hasDate || this.#hasTime;
+  }
+  toISOString() {
+    let iso = super.toISOString();
+    if (this.isDate())
+      return iso.slice(0, 10);
+    if (this.isTime())
+      return iso.slice(11, 23);
+    if (this.#offset === null)
+      return iso.slice(0, -1);
+    if (this.#offset === "Z" || this.#offset === "z")
+      return iso;
+    let offset = +this.#offset.slice(1, 3) * 60 + +this.#offset.slice(4, 6);
+    offset = this.#offset[0] === "-" ? offset : -offset;
+    let offsetDate = new Date(this.getTime() - offset * 6e4);
+    return offsetDate.toISOString().slice(0, -1) + this.#offset;
+  }
+  static wrapAsOffsetDateTime(jsDate, offset = "Z") {
+    let date = new _TomlDate(jsDate);
+    date.#offset = offset;
+    return date;
+  }
+  static wrapAsLocalDateTime(jsDate) {
+    let date = new _TomlDate(jsDate);
+    date.#offset = null;
+    return date;
+  }
+  static wrapAsLocalDate(jsDate) {
+    let date = new _TomlDate(jsDate);
+    date.#hasTime = false;
+    date.#offset = null;
+    return date;
+  }
+  static wrapAsLocalTime(jsDate) {
+    let date = new _TomlDate(jsDate);
+    date.#hasDate = false;
+    date.#offset = null;
+    return date;
+  }
+};
+
+// ../../node_modules/.pnpm/smol-toml@1.9.0/node_modules/smol-toml/dist/extract.js
+function isDigit(char, base = 10) {
+  return base === 16 ? char > 47 && char < 58 || char > 64 && char < 71 || char > 96 && char < 103 : char > 47 && char < 48 + base;
+}
+function isEndOfValue(char, delim) {
+  return char === 32 || char === 9 || char === 10 || char === 13 || // Structure end or next value delimiter
+  delim && (char === delim || char === 44) || // Comment
+  char === 35;
+}
+function extractValue(ctx, end) {
+  let errPtr = ctx.p;
+  let c = ctx.s.charCodeAt(ctx.p);
+  if (c === 91 || c === 123) {
+    ctx.d-- || TomlError.x("document contains excessively nested structures. aborting.", ctx);
+    let value = c === 91 ? parseArray(ctx) : parseInlineTable(ctx);
+    ctx.d++;
+    return value;
+  }
+  if (c === 34 || c === 39) {
+    return parseString(ctx);
+  }
+  if (c === 116) {
+    if (ctx.s.charCodeAt(++ctx.p) !== 114 || ctx.s.charCodeAt(++ctx.p) !== 117 || ctx.s.charCodeAt(++ctx.p) !== 101)
+      TomlError.x("invalid value", ctx, errPtr);
+    return ctx.p++, true;
+  }
+  if (c === 102) {
+    if (ctx.s.charCodeAt(++ctx.p) !== 97 || ctx.s.charCodeAt(++ctx.p) !== 108 || ctx.s.charCodeAt(++ctx.p) !== 115 || ctx.s.charCodeAt(++ctx.p) !== 101)
+      TomlError.x("invalid value", ctx, errPtr);
+    return ctx.p++, false;
+  }
+  if (c === 43 || c === 45) {
+    return parseNumber(ctx, ctx.p, ctx.s.charCodeAt(++ctx.p), 44 - c, end);
+  }
+  if (ctx.s.charCodeAt(ctx.p + 4) === 45 && ctx.s.charCodeAt(ctx.p + 7) === 45) {
+    return parseDate(ctx, c, end);
+  }
+  if (ctx.s.charCodeAt(ctx.p + 2) === 58) {
+    return parseTime(ctx, c, end);
+  }
+  return parseNumber(ctx, ctx.p, c, 0, end);
+}
+function parseNumber(ctx, startPtr, startChr, sign, endChr) {
+  let c = startChr;
+  let state = 0;
+  let hasUnderscores = false;
+  if (c === 105) {
+    if (ctx.s.charCodeAt(++ctx.p) !== 110 || ctx.s.charCodeAt(++ctx.p) !== 102)
+      TomlError.x("invalid value", ctx, startPtr);
+    return ctx.p++, (sign || 1) / 0;
+  }
+  if (c === 110) {
+    if (ctx.s.charCodeAt(++ctx.p) !== 97 || ctx.s.charCodeAt(++ctx.p) !== 110)
+      TomlError.x("invalid value", ctx, startPtr);
+    return ctx.p++, NaN;
+  }
+  if (c === 48) {
+    if (++ctx.p >= ctx.s.length || isEndOfValue(c = ctx.s.charCodeAt(ctx.p), endChr))
+      return ctx.bi === true ? 0n : 0;
+    if (!sign) {
+      if (c === 120)
+        return parseIntegerBaseN(ctx, startPtr, 16, endChr);
+      else if (c === 98)
+        return parseIntegerBaseN(ctx, startPtr, 2, endChr);
+      else if (c === 111)
+        return parseIntegerBaseN(ctx, startPtr, 8, endChr);
+    }
+    if (c === 46)
+      state = 2;
+    else if (c === 101 || c === 69)
+      state = 4;
+    else
+      TomlError.x("illegal leading zero", ctx, startPtr);
+  } else if (!isDigit(c))
+    TomlError.x("invalid value", ctx, startPtr);
+  while (++ctx.p < ctx.s.length && (c = ctx.s.charCodeAt(ctx.p), !isEndOfValue(c, endChr))) {
+    if (!state)
+      state = 1;
+    if (c === 95) {
+      if (!(state & 1))
+        TomlError.x("illegal underscore", ctx);
+      state += 11;
+      hasUnderscores = true;
+    } else if (state === 1 && c === 46)
+      state = 2;
+    else if ((state === 1 || state === 3) && (c === 101 || c === 69))
+      state = 4;
+    else if (state === 4 && (c === 43 || c === 45)) ; else if (!isDigit(c))
+      TomlError.x(`illegal character in numeric literal`, ctx);
+    else if (state > 9)
+      state -= 11;
+    else if (!(state & 1))
+      state++;
+  }
+  if (!state) {
+    let val = (startChr - 48) * (sign || 1);
+    return ctx.bi === true ? BigInt(val) : val;
+  }
+  if (!(state & 1))
+    TomlError.x("unfinished numeric value", ctx, startPtr);
+  let str = ctx.s.slice(startPtr, ctx.p);
+  if (hasUnderscores)
+    str = str.replaceAll("_", "");
+  return state > 1 ? parseFloat(str) : parseInteger(ctx, str, 10, startPtr);
+}
+function parseIntegerBaseN(ctx, startPtr, base, endChr) {
+  let c, underscore = 1;
+  while (++ctx.p < ctx.s.length && (c = ctx.s.charCodeAt(ctx.p), !isEndOfValue(c, endChr))) {
+    if (c === 95) {
+      if (underscore & 1)
+        TomlError.x("illegal underscore", ctx);
+      underscore = 3;
+    } else if (!isDigit(c, base))
+      TomlError.x(`illegal character in numeric literal`, ctx);
+    else if (underscore & 1)
+      underscore--;
+  }
+  if (underscore & 1)
+    TomlError.x("unfinished numeric value", ctx);
+  let str = ctx.s.slice(startPtr + 2, ctx.p);
+  if (underscore)
+    str = str.replaceAll("_", "");
+  return parseInteger(ctx, str, base, startPtr);
+}
+function parseInteger(ctx, str, base, startPtr) {
+  if (ctx.bi !== true)
+    int: {
+      let val = parseInt(str, base);
+      if (!Number.isSafeInteger(val)) {
+        if (ctx.bi)
+          break int;
+        TomlError.x("integer value cannot be represented losslessly", ctx, startPtr);
+      }
+      return val;
+    }
+  return base === 10 ? BigInt(str) : BigInt((base === 2 ? "0b" : base === 8 ? "0o" : "0x") + str);
+}
+function parseDate(ctx, c, endChr) {
+  let startPtr = ctx.p++, unsafeSeparator;
+  if (!isDigit(c) || !isDigit(ctx.s.charCodeAt(ctx.p++)) || !isDigit(ctx.s.charCodeAt(ctx.p++)) || !isDigit(ctx.s.charCodeAt(ctx.p++))) {
+    return parseNumber(ctx, ctx.p = startPtr, c, 0, endChr);
+  }
+  ctx.p += 5;
+  if (!isDigit(ctx.s.charCodeAt(ctx.p++)))
+    TomlError.x("invalid date-time: date part is malformed", ctx, startPtr);
+  if (ctx.p >= ctx.s.length || ((c = ctx.s.charCodeAt(ctx.p)) !== 32 || (unsafeSeparator = true, !isDigit(ctx.s.charCodeAt(ctx.p + 1)))) && c !== 84 && c !== 116) {
+    let t2 = ctx.s.slice(startPtr, ctx.p);
+    return readDate(ctx, t2, 3, false, startPtr);
+  }
+  if (ctx.s.charCodeAt(ctx.p += 3) !== 58)
+    TomlError.x("invalid date-time: time part is malformed", ctx, startPtr);
+  if (ctx.s.charCodeAt(ctx.p += 3) === 58)
+    ctx.p += 3;
+  if (ctx.s.charCodeAt(ctx.p) === 46)
+    while (isDigit(ctx.s.charCodeAt(++ctx.p)))
+      ;
+  if (c = ctx.s.charCodeAt(ctx.p)) {
+    if (c === 90 || c === 122) {
+      let t2 = ctx.s.slice(startPtr, ++ctx.p);
+      return readDate(ctx, t2, 1, unsafeSeparator, startPtr, "[+00:00]");
+    }
+    if (c === 43 || c === 45) {
+      let t2 = ctx.s.slice(startPtr, ctx.p += 6);
+      return readDate(ctx, t2, 1, unsafeSeparator, startPtr, !ctx.ld && "[" + ctx.s.slice(ctx.p - 6, ctx.p) + "]");
+    }
+  }
+  let t = ctx.s.slice(startPtr, ctx.p);
+  return readDate(ctx, t, 2, unsafeSeparator, startPtr);
+}
+function parseTime(ctx, c, endChr) {
+  let start = ctx.p;
+  if (!isDigit(c) || !isDigit(ctx.s.charCodeAt(++ctx.p))) {
+    return parseNumber(ctx, --ctx.p, c, 0, endChr);
+  }
+  if (ctx.s.charCodeAt(ctx.p += 4) === 58)
+    ctx.p += 3;
+  if (ctx.s.charCodeAt(ctx.p) === 46)
+    while (isDigit(ctx.s.charCodeAt(++ctx.p)))
+      ;
+  let t = ctx.s.slice(start, ctx.p);
+  return readDate(ctx, t, 4, false, start);
+}
+function readDate(ctx, str, type, unsafeDelim, errPtr, temporalSuffix) {
+  if (ctx.ld) {
+    let date = new TomlDate(str, type, unsafeDelim);
+    if (!date.isValid())
+      TomlError.x("invalid date", ctx, errPtr);
+    return date;
+  }
+  try {
+    if (temporalSuffix)
+      str += temporalSuffix;
+    switch (type) {
+      case 1:
+        return Temporal.ZonedDateTime.from(str);
+      case 2:
+        return Temporal.PlainDateTime.from(str);
+      case 3:
+        return Temporal.PlainDate.from(str);
+      case 4:
+        return Temporal.PlainTime.from(str);
+    }
+  } catch (e) {
+    TomlError.x(e instanceof Error ? e.message : "" + e, ctx, errPtr);
+  }
+}
+
+// ../../node_modules/.pnpm/smol-toml@1.9.0/node_modules/smol-toml/dist/util.js
+function skipComment(ctx) {
+  for (; ctx.p < ctx.s.length; ctx.p++) {
+    let c = ctx.s.charCodeAt(ctx.p);
+    if (c === 10)
+      break;
+    if (c === 13 && ctx.s.charCodeAt(ctx.p + 1) === 10) {
+      ctx.p++;
+      break;
+    }
+    if (c < 32 && c !== 9 || c === 127) {
+      TomlError.x("control characters are not allowed in comments", ctx);
+    }
+  }
+}
+function skipVoid(ctx, banNewLines, banComments) {
+  let c;
+  while (ctx.p < ctx.s.length) {
+    while (ctx.p < ctx.s.length && ((c = ctx.s.charCodeAt(ctx.p)) === 32 || c === 9 || !banNewLines && (c === 10 || c === 13 && ctx.s.charCodeAt(ctx.p + 1) === 10)))
+      ctx.p++;
+    if (banComments || c !== 35)
+      break;
+    skipComment(ctx);
+  }
+}
+
+// ../../node_modules/.pnpm/smol-toml@1.9.0/node_modules/smol-toml/dist/struct.js
+function parseKey(ctx, end = 61) {
+  let startPtr;
+  let state = 0;
+  let parsed = [];
+  let sliceStart;
+  let c = ctx.s.charCodeAt(startPtr = ctx.p);
+  do {
+    if (c === end) {
+      if (!state)
+        TomlError.x("unexpected end of key", ctx);
+      if (state === 1)
+        parsed.push(ctx.s.slice(sliceStart, ctx.p));
+      return ctx.p++, parsed;
+    } else if (c === 46) {
+      if (!state)
+        TomlError.x("illegal empty bare key", ctx);
+      if (state === 1)
+        parsed.push(ctx.s.slice(sliceStart, ctx.p));
+      state = 0;
+    } else if (!state && (c === 34 || c === 39)) {
+      if (c === ctx.s.charCodeAt(ctx.p + 1) && c === ctx.s.charCodeAt(ctx.p + 2))
+        TomlError.x("illegal quoted key: multiline strings are not allowed", ctx);
+      parsed.push(parseString(ctx));
+      state = 2;
+      ctx.p--;
+    } else if (c === 32 || c === 9) {
+      if (state === 1) {
+        parsed.push(ctx.s.slice(sliceStart, ctx.p));
+        state = 2;
+      }
+    } else if (state === 2 || c < 48 && c !== 45 || c > 57 && c < 65 || c > 90 && c < 97 && c !== 95 || c > 122) {
+      TomlError.x("illegal character in key", ctx);
+    } else if (!state) {
+      state = 1;
+      sliceStart = ctx.p;
+    }
+  } while (c = ctx.s.charCodeAt(++ctx.p));
+  TomlError.x("incomplete key-value: cannot find end of key", ctx, startPtr);
+}
+function parseInlineTable(ctx) {
+  let startPtr = ctx.p++;
+  let res = /* @__PURE__ */ Object.create(null);
+  let seen = /* @__PURE__ */ new Set();
+  let c;
+  while (ctx.p < ctx.s.length) {
+    skipVoid(ctx);
+    if ((c = ctx.s.charCodeAt(ctx.p)) === 125) {
+      ctx.p++;
+      return res;
+    }
+    let k;
+    let t = res;
+    let hasOwn = false;
+    let errPtr = ctx.p;
+    let key = parseKey(ctx);
+    for (let i = 0; i < key.length; i++) {
+      if (i)
+        t = hasOwn ? t[k] : t[k] = /* @__PURE__ */ Object.create(null);
+      k = key[i];
+      if ((hasOwn = Object.hasOwn(t, k)) && (typeof t[k] !== "object" || seen.has(t[k]))) {
+        TomlError.x("trying to redefine an already defined value", ctx, errPtr);
+      }
+      let unsafe = k === "__proto__";
+      if (ctx.uk && (unsafe || k === "constructor")) {
+        t = ctx.uk !== 1 && TomlError.x("document contains an unsafe property", ctx, errPtr);
+        break;
+      }
+      if (!hasOwn && unsafe) {
+        Object.defineProperty(t, k, { enumerable: true, configurable: true, writable: true });
+      }
+    }
+    if (hasOwn) {
+      TomlError.x("trying to redefine an already defined value", ctx, errPtr);
+    }
+    skipVoid(ctx, true, true);
+    let value = extractValue(
+      ctx,
+      125
+      /* } */
+    );
+    if (t && typeof (t[k] = value) === "object")
+      seen.add(value);
+    skipVoid(ctx);
+    if ((c = ctx.s.charCodeAt(ctx.p++)) === 125) {
+      return res;
+    }
+    if (c !== 44)
+      TomlError.x("expected comma or end of structure", ctx, ctx.p - 1);
+  }
+  TomlError.x("unfinished table", ctx, startPtr);
+}
+function parseArray(ctx) {
+  let startPtr = ctx.p++;
+  let res = [];
+  let c;
+  while (ctx.p < ctx.s.length) {
+    skipVoid(ctx);
+    if ((c = ctx.s.charCodeAt(ctx.p)) === 93) {
+      ctx.p++;
+      return res;
+    }
+    res.push(extractValue(
+      ctx,
+      93
+      /* ] */
+    ));
+    skipVoid(ctx);
+    if ((c = ctx.s.charCodeAt(ctx.p++)) === 93) {
+      return res;
+    }
+    if (c !== 44)
+      TomlError.x("expected comma or end of structure", ctx, ctx.p - 1);
+  }
+  TomlError.x("unfinished array", ctx, startPtr);
+}
+
+// ../../node_modules/.pnpm/smol-toml@1.9.0/node_modules/smol-toml/dist/parse.js
+function peekTable(ctx, key, table, meta, type) {
+  let t = table;
+  let m = meta;
+  let k;
+  let hasOwn = false;
+  let state;
+  for (let i = 0; i < key.length; i++) {
+    if (i) {
+      t = hasOwn ? t[k] : t[k] = /* @__PURE__ */ Object.create(null);
+      m = (state = m[k]).c;
+      if (type === 0 && (state.t === 1 || state.t === 2)) {
+        return null;
+      }
+      if (state.t === 2) {
+        let l = t.length - 1;
+        t = t[l];
+        m = m[l].c;
+      }
+    }
+    k = key[i];
+    if ((hasOwn = Object.hasOwn(t, k)) && m[k]?.t === 0 && m[k]?.d) {
+      return null;
+    }
+    if (!hasOwn) {
+      let unsafe = k === "__proto__";
+      if (ctx.uk && (unsafe || k === "constructor"))
+        return false;
+      if (unsafe) {
+        Object.defineProperty(t, k, { enumerable: true, configurable: true, writable: true });
+        Object.defineProperty(m, k, { enumerable: true, configurable: true, writable: true });
+      }
+      m[k] = {
+        t: i < key.length - 1 && type === 2 ? 3 : type,
+        d: false,
+        i: 0,
+        c: /* @__PURE__ */ Object.create(null)
+      };
+    }
+  }
+  state = m[k];
+  if (state.t !== type && !(type === 1 && state.t === 3)) {
+    return null;
+  }
+  if (type === 2) {
+    if (!state.d) {
+      state.d = true;
+      t[k] = [];
+    }
+    t[k].push(t = /* @__PURE__ */ Object.create(null));
+    state.c[state.i++] = state = { t: 1, d: false, i: 0, c: /* @__PURE__ */ Object.create(null) };
+  }
+  if (state.d) {
+    return null;
+  }
+  state.d = true;
+  if (type === 1) {
+    t = hasOwn ? t[k] : t[k] = /* @__PURE__ */ Object.create(null);
+  } else if (type === 0 && hasOwn) {
+    return null;
+  }
+  return [k, t, state.c];
+}
+function validateTablePeek(ctx, peek, ptr) {
+  if (peek === null || ctx.uk === 2)
+    TomlError.x(peek === null ? "trying to redefine an already defined table or value" : "document contains an unsafe property", ctx, ptr);
+}
+function parse(toml, options = {}) {
+  let ctx = {
+    s: toml,
+    p: 0,
+    d: options.maxDepth ?? 1e3,
+    bi: options.integersAsBigInt ?? false,
+    ld: options.useLegacyDate ?? true,
+    uk: options.unsafeKeyBehaviour === "throw" ? 2 : options.unsafeKeyBehaviour === "drop" ? 1 : 0
+  };
+  let res = /* @__PURE__ */ Object.create(null);
+  let meta = /* @__PURE__ */ Object.create(null);
+  let tmp;
+  let skipping = false;
+  let tbl = res;
+  let m = meta;
+  if (toml.charCodeAt(0) === 65279)
+    ctx.p++;
+  skipVoid(ctx);
+  while (ctx.p < toml.length) {
+    if (toml.charCodeAt(ctx.p) === 91) {
+      let isTableArray = toml.charCodeAt(++ctx.p) === 91;
+      tmp = ctx.p += +isTableArray;
+      skipping = false;
+      let k = parseKey(
+        ctx,
+        93
+        /* ] */
+      );
+      if (isTableArray) {
+        if (toml.charCodeAt(ctx.p) !== 93) {
+          TomlError.x("expected end of table array declaration", ctx);
+        }
+        ctx.p++;
+      }
+      let p = peekTable(
+        ctx,
+        k,
+        res,
+        meta,
+        isTableArray ? 2 : 1
+        /* Type.EXPLICIT */
+      );
+      if (!p) {
+        validateTablePeek(ctx, p, tmp);
+        skipping = true;
+      } else {
+        m = p[2];
+        tbl = p[1];
+      }
+    } else {
+      tmp = ctx.p;
+      let k = parseKey(ctx);
+      let p = peekTable(
+        ctx,
+        k,
+        tbl,
+        m,
+        0
+        /* Type.DOTTED */
+      );
+      if (!p && !skipping)
+        validateTablePeek(ctx, p, tmp);
+      skipVoid(ctx, true, true);
+      let v = extractValue(ctx, void 0);
+      if (p && !skipping)
+        p[1][p[0]] = v;
+    }
+    skipVoid(ctx, true);
+    if (ctx.p < toml.length && (tmp = toml.charCodeAt(ctx.p)) !== 10 && (tmp !== 13 || toml.charCodeAt(ctx.p + 1) !== 10)) {
+      TomlError.x("each key-value declaration must be followed by an end-of-line", ctx);
+    }
+    skipVoid(ctx);
+  }
+  return res;
+}
+
+// src/toml-config.ts
+var TOML_BLOCK = [
+  `[mcp_servers.${SERVER_NAME}]`,
+  `command = ${JSON.stringify(SERVER.command)}`,
+  `args = [${SERVER.args.map((arg) => JSON.stringify(arg)).join(", ")}]`,
+  ""
+].join("\n");
+function isTable(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value) && !(value instanceof Date);
+}
+function parseToml(text) {
+  try {
+    return parse(text, { integersAsBigInt: true });
+  } catch {
+    return void 0;
+  }
+}
+function serverState(config) {
+  const servers = config.mcp_servers;
+  if (!isTable(servers) || !(SERVER_NAME in servers)) return "missing";
+  const server = servers[SERVER_NAME];
+  return isTable(server) && isOurServer(server.command, server.args) ? "present" : "different";
+}
+function keepsEverythingElse(before, after) {
+  const { mcp_servers: servers, ...rest } = after;
+  if (!isTable(servers)) return false;
+  const { [SERVER_NAME]: server, ...others } = servers;
+  const { mcp_servers: previous = {}, ...previousRest } = before;
+  return isTable(server) && isDeepStrictEqual({ ...server }, SERVER) && isDeepStrictEqual(others, { ...previous }) && isDeepStrictEqual(rest, previousRest);
+}
+function append(text) {
+  if (text.trim() === "") return TOML_BLOCK;
+  const eol = text.includes("\r\n") ? "\r\n" : "\n";
+  const separator = text.endsWith("\n") ? eol : eol + eol;
+  return text + separator + TOML_BLOCK.replaceAll("\n", eol);
+}
+function addTomlServer(ctx, file) {
+  const text = readText(file) ?? "";
+  const refuse = (reason) => new SetupError(`${display(ctx, file)} ${reason}. Add the formhaus server by hand. The file was not changed.`);
+  const config = parseToml(text);
+  if (config === void 0) throw refuse("is not valid TOML");
+  if ("mcp_servers" in config && !isTable(config.mcp_servers)) throw refuse("has an mcp_servers value that is not a table");
+  const state = serverState(config);
+  if (state !== "missing") return state;
+  const next = append(text);
+  const updated = parseToml(next);
+  if (updated === void 0 || !keepsEverythingElse(config, updated)) throw refuse("defines mcp_servers in a way Formhaus cannot extend");
+  writeText(ctx, file, next);
+  return "added";
+}
+
+// src/agents.ts
+function codexHome(ctx) {
+  return ctx.env.CODEX_HOME || join(ctx.home, ".codex");
+}
+function claudeDesktopDir(ctx) {
+  if (ctx.platform === "darwin") return join(ctx.home, "Library", "Application Support", "Claude");
+  if (ctx.platform === "win32") return join(ctx.env.APPDATA || join(ctx.home, "AppData", "Roaming"), "Claude");
+  return void 0;
+}
+function found(ctx, directory, bin) {
+  return isDirectory(directory) || findOnPath(ctx, bin) !== void 0;
+}
+function isProject(ctx) {
+  return ctx.cwd !== ctx.home && existsSync(join(ctx.cwd, "package.json"));
+}
+var codex = {
+  name: "Codex",
+  detect: (ctx) => found(ctx, codexHome(ctx), "codex"),
+  apply(ctx) {
+    const file = join(codexHome(ctx), "config.toml");
+    return [step(ctx, "Codex", "MCP server", file, () => addTomlServer(ctx, file))];
+  }
+};
+var cursor = {
+  name: "Cursor",
+  detect: (ctx) => found(ctx, join(ctx.home, ".cursor"), "cursor"),
+  apply(ctx) {
+    const file = join(ctx.home, ".cursor", "mcp.json");
+    const changes = [step(ctx, "Cursor", "MCP server", file, () => addJsonServer(ctx, file))];
+    if (!isProject(ctx)) return changes;
+    const rule = join(ctx.cwd, ".cursor", "rules", "formhaus.mdc");
+    changes.push(step(ctx, "Cursor", "formhaus rule", rule, () => writeIfChanged(ctx, rule, formhaus_default, ctx.cwd)));
+    return changes;
+  }
+};
+var claudeDesktop = {
+  name: "Claude Desktop",
+  detect: (ctx) => {
+    const directory = claudeDesktopDir(ctx);
+    return directory !== void 0 && isDirectory(directory);
+  },
+  apply(ctx) {
+    const directory = claudeDesktopDir(ctx);
+    const file = join(directory, "claude_desktop_config.json");
+    return [step(ctx, "Claude Desktop", "MCP server", file, () => addJsonServer(ctx, file))];
+  }
+};
+var AGENTS = [claudeCode, codex, cursor, claudeDesktop];
+var MANUAL_AGENTS = [
+  { name: "Windsurf", detect: (ctx) => found(ctx, join(ctx.home, ".codeium", "windsurf"), "windsurf") },
+  { name: "Gemini CLI", detect: (ctx) => found(ctx, join(ctx.home, ".gemini"), "gemini") },
+  { name: "OpenCode", detect: (ctx) => found(ctx, join(ctx.home, ".config", "opencode"), "opencode") },
+  { name: "Claude Desktop", detect: (ctx) => ctx.platform === "linux" && isDirectory(join(ctx.home, ".config", "Claude")) },
+  { name: "VS Code", detect: (ctx) => findOnPath(ctx, "code") !== void 0 }
+];
+
+// src/run.ts
+var LABELS = {
+  added: ["added", "will add"],
+  updated: ["updated", "will update"],
+  present: ["already set up", "already set up"],
+  different: ["different server, check it", "different server, check it"],
+  failed: ["failed", "failed"]
+};
+function label(ctx, state) {
+  return LABELS[state][ctx.dryRun ? 1 : 0];
+}
+function printChanges(ctx, changes, print) {
+  const width = (pick) => Math.max(...changes.map((change) => pick(change).length));
+  const agentWidth = width((change) => change.agent);
+  const itemWidth = width((change) => change.item);
+  const stateWidth = width((change) => label(ctx, change.state));
+  for (const change of changes) {
+    const row = [change.agent.padEnd(agentWidth), change.item.padEnd(itemWidth), label(ctx, change.state).padEnd(stateWidth), change.where];
+    print(`  ${row.join("  ")}`);
+    if (change.error) print(`    ${change.error}`);
+  }
+}
+function printManual(names, print) {
+  print(names.length > 0 ? `Set up by hand: ${names.join(", ")}` : "Set up any other MCP client by hand:");
+  print(`  Add a stdio MCP server named "${SERVER_NAME}" with command "${SERVER.command}" and args ${JSON.stringify(SERVER.args)}.`);
+  print(`  Guide: ${GUIDE_URL}`);
+}
+function setup(ctx, print) {
+  const agents = AGENTS.filter((agent) => agent.detect(ctx));
+  const manual = MANUAL_AGENTS.filter((agent) => agent.detect(ctx)).map((agent) => agent.name);
+  if (ctx.dryRun) print("Dry run: nothing is written.");
+  if (agents.length === 0) {
+    print("No supported coding agent found. Formhaus sets up Claude Code, Codex, Cursor and Claude Desktop.");
+    printManual(manual, print);
+    return 0;
+  }
+  print(`Found ${agents.map((agent) => agent.name).join(", ")}.`);
+  const changes = agents.flatMap((agent) => agent.apply(ctx));
+  print("");
+  printChanges(ctx, changes, print);
+  if (manual.length > 0) {
+    print("");
+    printManual(manual, print);
+  }
+  const failed = changes.some((change) => change.state === "failed");
+  const changed = changes.some((change) => change.state === "added" || change.state === "updated");
+  print("");
+  const different = changes.some((change) => change.state === "different");
+  if (different) {
+    print(
+      `A "${SERVER_NAME}" server with another command is configured where marked. Formhaus left it unchanged. Check that you trust it.`
+    );
+  }
+  if (failed) print("Some steps failed. Fix the errors above and run formhaus again.");
+  else if (ctx.dryRun) print("Run without --dry-run to apply.");
+  else if (changed) print("Done. Restart your agents to load the Formhaus MCP server.");
+  else if (!different) print("Everything is already set up.");
+  return failed ? 1 : 0;
+}
+
+// src/main.ts
+var HELP = `Usage: npx formhaus [setup] [options]
+
+Adds the Formhaus MCP server (npx -y @formhaus/mcp) to the coding agents
+installed on this machine: Claude Code, Codex, Cursor and Claude Desktop.
+Installs the formhaus-create-form skill in Claude Code and, inside a project,
+the Formhaus rule in .cursor/rules. Running it again changes nothing.
+
+Options:
+  --dry-run      Show the planned changes and write nothing
+  -h, --help     Show this help
+  -v, --version  Show the version`;
+function main(argv, ctx, print, printError) {
+  let parsed;
+  try {
+    parsed = parse2(argv);
+  } catch (error) {
+    printError(`${error instanceof Error ? error.message : String(error)}
+Run npx formhaus --help for usage.`);
+    return 1;
+  }
+  const { values, positionals } = parsed;
+  if (values.help || values.version) {
+    print(values.help ? HELP : version);
+    return 0;
+  }
+  if (positionals.length > 1 || positionals.length === 1 && positionals[0] !== "setup") {
+    printError(`Unknown command: ${positionals.join(" ")}
+Run npx formhaus --help for usage.`);
+    return 1;
+  }
+  return setup({ ...ctx, dryRun: values["dry-run"] === true }, print);
+}
+function parse2(argv) {
+  return parseArgs({
+    args: argv,
+    allowPositionals: true,
+    options: {
+      "dry-run": { type: "boolean" },
+      help: { type: "boolean", short: "h" },
+      version: { type: "boolean", short: "v" }
+    }
+  });
+}
+
+// src/cli.ts
+process.exitCode = main(
+  process.argv.slice(2),
+  { home: homedir(), cwd: process.cwd(), env: process.env, platform: process.platform },
+  (line) => console.log(line),
+  (line) => console.error(line)
+);
+/*! Bundled license information:
+
+smol-toml/dist/error.js:
+smol-toml/dist/primitive.js:
+smol-toml/dist/date.js:
+smol-toml/dist/extract.js:
+smol-toml/dist/util.js:
+smol-toml/dist/struct.js:
+smol-toml/dist/parse.js:
+smol-toml/dist/stringify.js:
+smol-toml/dist/index.js:
+  (*!
+   * Copyright (c) Squirrel Chat et al., All rights reserved.
+   * SPDX-License-Identifier: BSD-3-Clause
+   *
+   * Redistribution and use in source and binary forms, with or without
+   * modification, are permitted provided that the following conditions are met:
+   *
+   * 1. Redistributions of source code must retain the above copyright notice, this
+   *    list of conditions and the following disclaimer.
+   * 2. Redistributions in binary form must reproduce the above copyright notice,
+   *    this list of conditions and the following disclaimer in the
+   *    documentation and/or other materials provided with the distribution.
+   * 3. Neither the name of the copyright holder nor the names of its contributors
+   *    may be used to endorse or promote products derived from this software without
+   *    specific prior written permission.
+   *
+   * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
+   * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+   * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+   * DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE
+   * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+   * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
+   * SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
+   * CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
+   * OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+   * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+   *)
+*/

package/package.json

@@ -1,6 +1,48 @@
 {
   "name": "formhaus",
-  "version": "0.0.0-stage",
-  "stub": true,
-  "description": "Temporary package placeholder for staged publishing"
+  "version": "0.14.2",
+  "description": "Set up the Formhaus MCP server and agent instructions in Claude Code, Codex, Cursor and Claude Desktop with one command.",
+  "type": "module",
+  "engines": {
+    "node": ">=20"
+  },
+  "bin": {
+    "formhaus": "./dist/cli.js"
+  },
+  "files": [
+    "dist"
+  ],
+  "devDependencies": {
+    "@types/node": "^20",
+    "smol-toml": "1.9.0",
+    "tsup": "^8.5.1",
+    "typescript": "^5.7.3",
+    "vitest": "^4.1.3"
+  },
+  "license": "MIT",
+  "homepage": "https://formhaus.dev/guide/mcp.html",
+  "bugs": {
+    "url": "https://github.com/ignsm/formhaus/issues"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/ignsm/formhaus.git",
+    "directory": "packages/formhaus"
+  },
+  "keywords": [
+    "formhaus",
+    "mcp",
+    "claude-code",
+    "codex",
+    "cursor",
+    "ai-agents",
+    "forms",
+    "cli"
+  ],
+  "scripts": {
+    "build": "tsup",
+    "test": "vitest run",
+    "typecheck": "tsc --noEmit",
+    "clean": "rm -rf dist"
+  }
 }