modwright 0.1.0

package/scaffolds/stardewvalley/new-csharp-mod.yaml

@@ -0,0 +1,195 @@
+# new-csharp-mod (Stardew Valley). Adds a SMAPI C# mod project to an existing Stardew Valley ModWright
+# project: a `src/<name>/` folder holding the `.csproj` the wiki's IDE
+# reference gives (Microsoft.NET.Sdk, net6.0, the Pathoschild.Stardew.ModBuildConfig
+# package reference), the Get Started guide's ModEntry.cs and manifest.json
+# (with the literal version rather than `%ProjectVersion%`, see below), and the
+# project source and dependencies that make the manifest visible to the
+# surface's rules.
+#
+# Two things this scaffold decides for the author:
+# `<EnableModDeploy>false</EnableModDeploy>` and `<EnableModZip>false</EnableModZip>`
+# are set, so the build package does not copy the mod into the game's Mods
+# folder on every build and ModWright's own safety-backed deploy is the one
+# path that writes there. Note the cost: with both off,
+# the package's deploy task returns before it reads the manifest, so it never
+# substitutes `%ProjectVersion%` and never assembles a mod folder — the build
+# output is the DLL alone. The manual checklist carries what that leaves the
+# author to do until a Stardew deploy target exists.
+# Building needs the game installed (the package
+# refuses without `Stardew Valley.dll` and `StardewModdingAPI.dll` beside the
+# game), so the DLL the manifest names is a build output
+# and never sits beside the source manifest; the surface's entrydll-exists
+# rule reports that as an info for a manifest with a .csproj beside it, not
+# as the block a deployed manifest without its DLL gets.
+id: stardewvalley.new-csharp-mod
+game: stardewvalley
+title: New SMAPI C# mod project
+summary: Add a SMAPI C# mod under src/<name>/ — the wiki's .csproj (net6.0, ModBuildConfig, deploy and zip handed to ModWright), the Get Started ModEntry.cs and manifest.json — and register it as a project source with the dotnet and SMAPI dependencies.
+modTypes: [plugin, packaging]
+needs: {}
+inputs:
+  - type: string
+    name: name
+    prompt: Project name (also the assembly, root namespace, folder and EntryDll name; a C# identifier).
+    pattern: "^[A-Za-z][A-Za-z0-9_]*$"
+  - type: string
+    name: uniqueId
+    prompt: The manifest UniqueID, YourName.YourModName (letters, numbers, underscores, periods, hyphens; never changed once published).
+    pattern: "^[a-zA-Z0-9_.-]+$"
+  - type: string
+    name: author
+    prompt: Author name (no quotes or backslashes; it is written into JSON).
+    default: "Unknown"
+    pattern: '^[^"\\\x00-\x1f]+$'
+  - type: string
+    name: version
+    prompt: Initial version (major.minor.patch); written to both the .csproj and the manifest, which are bumped together.
+    default: "1.0.0"
+    pattern: "^(?:0|[1-9][0-9]*)\\.(?:0|[1-9][0-9]*)(?:\\.(?:0|[1-9][0-9]*))?(?:-(?:[a-zA-Z0-9]+[-.]?)+)?$"
+  - type: string
+    name: description
+    prompt: One or two sentences about the mod (no quotes or backslashes; it is written into JSON).
+    default: "One or two sentences about the mod."
+    pattern: '^[^"\\\x00-\x1f]+$'
+ids: []
+emits:
+  - op: ensure-dir
+    path: "src/${input.name}"
+  # The .csproj: the IDE reference's example (Sdk, AssemblyName, RootNamespace,
+  # Version, TargetFramework net6.0, the package reference) with the package
+  # at its current version and the two deploy/zip toggles.
+  - op: write-text
+    path: "src/${input.name}/${input.name}.csproj"
+    body: |
+      <Project Sdk="Microsoft.NET.Sdk">
+        <PropertyGroup>
+          <AssemblyName>${input.name}</AssemblyName>
+          <RootNamespace>${input.name}</RootNamespace>
+          <Version>${input.version}</Version>
+          <TargetFramework>net6.0</TargetFramework>
+          <!-- ModWright owns deploy and zip: the package would otherwise copy into Mods/ on every build. -->
+          <EnableModDeploy>false</EnableModDeploy>
+          <EnableModZip>false</EnableModZip>
+        </PropertyGroup>
+
+        <ItemGroup>
+          <PackageReference Include="Pathoschild.Stardew.ModBuildConfig" Version="4.4.0" />
+        </ItemGroup>
+      </Project>
+  # ModEntry.cs: the Get Started guide's first mod, with the project name as
+  # its namespace.
+  - op: write-text
+    path: "src/${input.name}/ModEntry.cs"
+    body: |
+      using System;
+      using Microsoft.Xna.Framework;
+      using StardewModdingAPI;
+      using StardewModdingAPI.Events;
+      using StardewModdingAPI.Utilities;
+      using StardewValley;
+
+      namespace ${input.name}
+      {
+          /// <summary>The mod entry point.</summary>
+          internal sealed class ModEntry : Mod
+          {
+              /*********
+              ** Public methods
+              *********/
+              /// <summary>The mod entry point, called after the mod is first loaded.</summary>
+              /// <param name="helper">Provides simplified APIs for writing mods.</param>
+              public override void Entry(IModHelper helper)
+              {
+                  helper.Events.Input.ButtonPressed += this.OnButtonPressed;
+              }
+
+
+              /*********
+              ** Private methods
+              *********/
+              /// <summary>Raised after the player presses a button on the keyboard, controller, or mouse.</summary>
+              /// <param name="sender">The event sender.</param>
+              /// <param name="e">The event data.</param>
+              private void OnButtonPressed(object? sender, ButtonPressedEventArgs e)
+              {
+                  // ignore if player hasn't loaded a save yet
+                  if (!Context.IsWorldReady)
+                      return;
+
+                  // print button presses to the console window
+                  this.Monitor.Log($"{Game1.player.Name} pressed {e.Button}.", LogLevel.Debug);
+              }
+          }
+      }
+  # manifest.json: the Get Started guide's manifest, field for field, with
+  # the literal version the guide itself uses. The mod-package doc's
+  # %ProjectVersion% token is substituted only when the package deploys or
+  # zips, and with both toggles off (header comment) it never does, so the
+  # token would reach SMAPI unreplaced and the mod would be refused.
+  - op: write-text
+    path: "src/${input.name}/manifest.json"
+    body: |
+      {
+        "Name": "${input.name}",
+        "Author": "${input.author}",
+        "Version": "${input.version}",
+        "Description": "${input.description}",
+        "UniqueID": "${input.uniqueId}",
+        "EntryDll": "${input.name}.dll",
+        "MinimumApiVersion": "4.0.0",
+        "UpdateKeys": []
+      }
+  - op: patch-project
+    add:
+      sources:
+        - id: "src-${input.name}"
+          path: "src/${input.name}"
+          kind: source
+      dependencies:
+        - id: dotnet
+          kind: tool
+          minVersion: "6.0"
+          url: "https://dotnet.microsoft.com/download"
+          notes: "`dotnet build -c Release` in src/<name>; the build package needs the game and SMAPI installed to resolve Stardew Valley.dll and StardewModdingAPI.dll."
+        - id: smapi
+          kind: loader
+          minVersion: "4.0.0"
+          url: "https://smapi.io"
+          notes: "MinimumApiVersion in the manifest; the mod loads only through StardewModdingAPI."
+templates: []
+# The manifest rules the source manifest must pass. entrydll-exists is not
+# listed: for a manifest with a .csproj beside it the rule reports the
+# missing DLL as an info (it is a build output), which is expected here.
+satisfies:
+  - stardewvalley.manifest.parses
+  - stardewvalley.manifest.required-fields
+  - stardewvalley.manifest.entry-or-content-pack
+  - stardewvalley.manifest.uniqueid
+  - stardewvalley.manifest.version
+  - stardewvalley.manifest.minimum-versions
+  - stardewvalley.manifest.extra-fields
+manual:
+  - title: Build against the installed game
+    steps:
+      - "With the game and SMAPI installed, run `dotnet build -c Release` in src/<name>; the package finds the game folder itself (or set GamePath, see https://smapi.io/package/custom-game-path)."
+      - "The build output is bin/Release/net6.0/<name>.dll and nothing else: with EnableModDeploy and EnableModZip both false the package's deploy task returns before it reads the manifest, so there is no deployed folder, no release zip, and no %ProjectVersion% substitution anywhere."
+    expected: "The build succeeds with no 'Any CPU' warning; bin/Release/net6.0 holds <name>.dll (manifest.json is not copied there)."
+  - title: Check in game
+    steps:
+      - "Assemble Mods/<name> by hand, since no deploy target is configured on this game yet: the built <name>.dll plus this project's manifest.json as it is (its Version is the literal the .csproj carries; bump both together). Alternatively set <EnableModZip>true</EnableModZip> for one build and unzip the '<name> <version>.zip' the package then writes into bin/Release/net6.0, which still never writes into Mods/."
+      - "Launch StardewModdingAPI.exe and press any key in game: the SMAPI console shows '<player> pressed <button>' at Debug level (the Get Started example's behaviour)."
+    expected: "SMAPI's log lists the mod in its 'Loaded N mods' block with no skipped-mods entry."
+claim:
+  idSuffix: csharp-mod
+  claim: "${input.name} is a SMAPI C# mod project under src/${input.name} (UniqueID ${input.uniqueId}, net6.0, ModBuildConfig 4.4.0 with deploy and zip handed to ModWright)."
+testRows:
+  - gate: S-0
+    title: "Mod builds and loads"
+    expected: "dotnet build succeeds against the installed game; SMAPI's log lists the mod with no skipped-mods entry and the button-press line appears at Debug."
+    manual: true
+    probeKinds: []
+evidence:
+  - "stardewvalley.toolchain.build.modbuildconfig-package"
+  - "stardewvalley.toolchain.build.deploy-and-zip-properties"
+  - "stardewvalley.toolchain.build.requires-the-game-installed"
+  - "stardewvalley.smapi.manifest.project-version-token"

package/scaffolds/stardewvalley/new-project.yaml

@@ -0,0 +1,184 @@
+# new-project (Stardew Valley). A `new-content-pack`, carried under the `new-project` id because the
+# `scaffold` tool bootstraps a project only for an id ending in
+# `.new-project` (src/server.ts), and a Content Patcher pack is the first
+# project on this game: it needs no toolchain, no compiler and no game
+# to author. Writes the pack the Content Patcher author
+# guide's quick-start describes — a `[CP] <name>` folder with
+# `manifest.json`, `content.json` and an `assets/` folder — plus the
+# ModWright project around it. tests/authored.yaml and ledger/claims.yaml
+# come from the engine's own per-apply steps, not an emit here.
+#
+# The pack is not empty: Content Patcher rejects a pack whose `Changes`
+# and `CustomLocations` are both empty ("content pack must specify the
+# Changes or CustomLocations fields"), so the quick-
+# start's `"Changes": [ // your changes will go here ]` would be refused
+# at load. The one starter patch is the wiki's own Mail data example
+# shape: an EditData on `Data/mail` adding a `{{ModId}}_`-prefixed letter,
+# which the 1.6 unique-string-ID convention asks for and which reaches no
+# player until something sends it ("This letter will have to be sent in a
+# separate patch", Modding:Mail data). Replacing it is the first manual
+# step.
+id: stardewvalley.new-project
+game: stardewvalley
+title: New Stardew Valley content pack project
+summary: Scaffold a fresh ModWright project holding one Content Patcher content pack — modwright.json (schemaVersion 2), the [CP] <name> folder with manifest.json, content.json (Format 2.9.0, one starter Data/mail patch) and assets/, .gitignore, and ledger/decisions.yaml.
+modTypes: [content-pack, packaging]
+needs: {}
+inputs:
+  - type: string
+    name: name
+    prompt: Mod name (the pack folder is "[CP] <name>", the author guide's convention).
+    pattern: "^[A-Za-z][A-Za-z0-9_-]*$"
+  - type: string
+    name: uniqueId
+    prompt: The manifest UniqueID, YourName.YourModName (letters, numbers, underscores, periods, hyphens; never changed once published).
+    pattern: "^[a-zA-Z0-9_.-]+$"
+  # author and description are the only free-text inputs that land inside a
+  # JSON string literal in a hand-written `write-text` body (every other one
+  # is already pattern-guarded). A `"` or `\` in either would emit a
+  # manifest.json that is not JSON at all — SMAPI then reports the mod as
+  # "parsing its manifest failed" and loads nothing — so they are refused up
+  # front rather than written and reported afterwards. Control characters go
+  # with them: a raw tab or newline inside a JSON string is invalid too.
+  - type: string
+    name: author
+    prompt: Author name (no double quotes or backslashes — it is written into manifest.json as-is).
+    default: "Unknown"
+    pattern: '^[^"\\\x00-\x1f]+$'
+  - type: string
+    name: version
+    prompt: Initial version (major.minor.patch, as SMAPI parses it).
+    default: "1.0.0"
+    pattern: "^(?:0|[1-9][0-9]*)\\.(?:0|[1-9][0-9]*)(?:\\.(?:0|[1-9][0-9]*))?(?:-(?:[a-zA-Z0-9]+[-.]?)+)?$"
+  - type: string
+    name: description
+    prompt: One or two sentences about the mod (the manifest Description; no double quotes or backslashes).
+    default: "One or two sentences about the mod."
+    pattern: '^[^"\\\x00-\x1f]+$'
+ids: []
+emits:
+  - op: ensure-dir
+    path: "[CP] ${input.name}/assets"
+  - op: write-text
+    path: ".gitignore"
+    ifExists: skip
+    # The same shape as the other two new-project scaffolds: suppressions.json
+    # and templates/manifest.json stay tracked so a reviewer reads them in a
+    # clean checkout, and the build manifest a later build step writes is
+    # ignored wherever outDir points.
+    body: |
+      .modwright/*
+      !.modwright/suppressions.json
+      !.modwright/templates/
+      .modwright/templates/*
+      !.modwright/templates/manifest.json
+      build/
+      .modwright-build-manifest.json
+  - op: write-text
+    path: "ledger/decisions.yaml"
+    body: |
+      decisions: []
+  # The project: one source of kind "content-pack" covering the pack
+  # folder, so every manifest and content rule sees the two files (the
+  # lesson cyberpunk2077/new-project.yaml records: a file outside every
+  # declared source is invisible to file-scoped rules). No build and no
+  # deploy yet: a Stardew deploy target is not built, and a content pack has
+  # nothing to compile — the pack folder is what gets copied into Mods/.
+  - op: write-text
+    path: "modwright.json"
+    body: |
+      {
+        "schemaVersion": 2,
+        "name": "${input.name}",
+        "game": "stardewvalley",
+        "version": "${input.version}",
+        "authors": ["${input.author}"],
+        "sources": [
+          { "id": "pack", "path": "[CP] ${input.name}", "kind": "content-pack" }
+        ]
+      }
+  # manifest.json: the author guide's quick-start manifest, field for
+  # field (Name, Author, Version, Description, UniqueID, UpdateKeys,
+  # ContentPackFor). UpdateKeys stays empty until the mod has a page; the
+  # guide's own comment on that line points at the update-checks wiki page.
+  - op: write-text
+    path: "[CP] ${input.name}/manifest.json"
+    body: |
+      {
+        "Name": "${input.name}",
+        "Author": "${input.author}",
+        "Version": "${input.version}",
+        "Description": "${input.description}",
+        "UniqueID": "${input.uniqueId}",
+        "UpdateKeys": [],
+        "ContentPackFor": {
+          "UniqueID": "Pathoschild.ContentPatcher"
+        }
+      }
+  # content.json: the quick-start's Format, the schema line the
+  # troubleshooting guide recommends for editors, and the one starter patch
+  # (see the header comment). `^` is a line break and `@` the player's name
+  # in mail text; `[#]` ends the body and names the letter.
+  - op: write-text
+    path: "[CP] ${input.name}/content.json"
+    body: |
+      {
+        "$schema": "https://smapi.io/schemas/content-patcher.json",
+        "Format": "2.9.0",
+        "Changes": [
+          {
+            "LogName": "Welcome letter",
+            "Action": "EditData",
+            "Target": "Data/mail",
+            "Entries": {
+              "{{ModId}}_Welcome": "Hi @,^^This letter was added by the ${input.name} content pack. Replace this patch with your first real change.^^  -${input.author}[#]Welcome from ${input.name}"
+            }
+          }
+        ]
+      }
+templates: []
+# Every rule below runs against the two files this scaffold writes and must
+# come back with zero findings: the manifest family and the content family. manifest.update-keys
+# is deliberately not listed — an empty UpdateKeys is its documented info,
+# not a failure, and a scaffolded mod has no page yet.
+satisfies:
+  - stardewvalley.manifest.parses
+  - stardewvalley.manifest.required-fields
+  - stardewvalley.manifest.entry-or-content-pack
+  - stardewvalley.manifest.uniqueid
+  - stardewvalley.manifest.version
+  - stardewvalley.manifest.extra-fields
+  - stardewvalley.content.parses
+  - stardewvalley.content.format
+  - stardewvalley.content.changes-present
+  - stardewvalley.content.patch-action
+  - stardewvalley.content.patch-target
+  - stardewvalley.content.patch-fields
+  - stardewvalley.content.fromfile-exists
+  - stardewvalley.content.patch-enabled
+  - stardewvalley.content.when-tokens
+manual:
+  - title: Replace the starter patch
+    steps:
+      - "Edit [CP] <name>/content.json: replace the Welcome letter patch with the first real change (the author guide's first example is a Load of Portraits/Abigail from assets/abigail.png), or run the new-cp-patch scaffold to append one."
+      - "Put any file a FromFile names under assets/; validate reports a FromFile that does not exist as a block."
+      - "Check both files at https://smapi.io/json (Manifest and Content Patcher formats) before shipping."
+    expected: "validate is clean; with the game installed, SMAPI's log lists the mod and Content Patcher's `patch summary` shows every patch loaded."
+  - title: Install and check in game
+    steps:
+      - "Copy the [CP] <name> folder into the game's Mods/ folder (deploy is not configured on this game yet) and launch StardewModdingAPI.exe."
+      - "In the SMAPI console run `patch summary` and find the pack's patches in the loaded | conditions | applied table."
+    expected: "The pack appears in the log's own 'Loaded N content packs:' list (not the 'Loaded N mods' list, which is C# mods only) under its manifest Name, followed by '| for Content Patcher', and nowhere in the 'Skipped mods' list."
+claim:
+  idSuffix: scaffolded
+  claim: "${input.name} is scaffolded as a ModWright project holding the Content Patcher pack [CP] ${input.name} (UniqueID ${input.uniqueId}, Format 2.9.0) with one starter Data/mail patch."
+testRows:
+  - gate: S-0
+    title: "Pack loads under SMAPI"
+    expected: "SMAPI's log lists the pack by its manifest Name in the 'Loaded N content packs:' list, '| for Content Patcher', with no 'Skipped mods' entry, and `patch summary` shows the Welcome letter patch as loaded."
+    manual: true
+    probeKinds: []
+evidence:
+  - "stardewvalley.contentpatcher.format.what-a-pack-is"
+  - "stardewvalley.contentpatcher.format.whole-pack-rejection-messages"
+  - "stardewvalley.game.versions.unique-string-ids-convention"

package/scaffolds/stardewvalley/sequences/content-pack.yaml

@@ -0,0 +1,31 @@
+# content-pack (Stardew Valley) — the smallest sequence: a Content Patcher
+# pack and its first real patch. A C# mod cannot compile without the game,
+# so the first Stardew project is always a content pack.
+id: stardewvalley.content-pack
+game: stardewvalley
+title: Content Patcher pack with one patch
+summary: A Content Patcher pack (manifest, content.json, assets/) and its first Load or EditImage patch over an asset the modder supplies.
+modType: content-pack
+inputs:
+  - name: modName
+    prompt: "Mod name; the pack folder is \"[CP] <name>\"."
+  - name: uniqueId
+    prompt: "The manifest UniqueID, YourName.YourModName (never changed once published)."
+steps:
+  - id: project
+    scaffold: stardewvalley.new-project
+    title: The pack and its project file
+    skipIf: project-exists
+    inputs:
+      name: "${sequence.modName}"
+      uniqueId: "${sequence.uniqueId}"
+  - id: patch
+    scaffold: stardewvalley.new-cp-patch
+    title: The first patch over a game asset
+    inputs:
+      folder: "[CP] ${sequence.modName}"
+    assets:
+      - name: file
+        prompt: "The file the patch loads or edits with (a PNG for an image target, a data file otherwise), placed under the pack's assets/ folder. Path relative to the pack folder, e.g. assets/portrait.png."
+        inputs: [fromFile]
+evidence: []

package/scripts/mw-tool.mjs

@@ -0,0 +1,184 @@
+#!/usr/bin/env node
+/**
+ * Call any ModWright tool from a shell, through a fresh server process, with
+ * no MCP client in the way.
+ *
+ *   npm run tool -- list [--schemas]
+ *   npm run tool -- call <tool> [key=value ...] [--json '<object>'] [--args-file <file>] [--out <file>]
+ *   npm run tool -- prompts
+ *   npm run tool -- prompt <name> [path=<project>] [--out <file>]
+ *
+ * Why: an MCP client's tool list is fixed at its handshake, so a server
+ * rebuilt after the session started is invisible to it. Every invocation
+ * here spawns the server that is on disk right now, so a rebuilt ModWright is usable from the next shell command,
+ * whatever the surrounding client believes its tools are.
+ *
+ * Argument values given as key=value are parsed as JSON when they parse
+ * (true, 3, ["a"], {"k":1}) and taken as strings otherwise, so
+ * `mode=apply` and `force=true` both do what they look like. `--json` and
+ * `--args-file` take a whole object; later sources override earlier ones,
+ * in the order file, --json, key=value. `--out` writes the result text to a
+ * file instead of stdout. MODWRIGHT_* environment variables are forwarded.
+ * Long tools (build_index) are given a generous request timeout; there is
+ * no 60 s ceiling here. Exit code 1 when the tool reports an error.
+ */
+import { Client } from "@modelcontextprotocol/sdk/client/index.js";
+import { StdioClientTransport, getDefaultEnvironment } from "@modelcontextprotocol/sdk/client/stdio.js";
+import { promises as fs } from "node:fs";
+import * as path from "node:path";
+import { fileURLToPath } from "node:url";
+
+const repoRoot = path.resolve(path.dirname(fileURLToPath(import.meta.url)), "..");
+const REQUEST_TIMEOUT_MS = 6 * 60 * 60 * 1000;
+
+const argv = process.argv.slice(2);
+const command = argv.shift();
+if (command !== "list" && command !== "call" && command !== "prompts" && command !== "prompt") {
+  usage();
+  process.exit(command === undefined || command === "--help" || command === "-h" ? 0 : 2);
+}
+
+function usage() {
+  process.stdout.write(
+    [
+      "usage:",
+      "  mw-tool list [--schemas]",
+      "  mw-tool call <tool> [key=value ...] [--json '<object>'] [--args-file <file>] [--out <file>]",
+      "  mw-tool prompts                     list the workflow prompts the server serves",
+      "  mw-tool prompt <name> [path=<dir>]  render one workflow prompt for a project",
+      "",
+      "Every call spawns a fresh ModWright server from dist/, so it always reflects the current build.",
+      "",
+    ].join("\n"),
+  );
+}
+
+function takeFlag(flag) {
+  const i = argv.indexOf(flag);
+  if (i === -1) return undefined;
+  const value = argv[i + 1];
+  argv.splice(i, 2);
+  return value;
+}
+
+function takeSwitch(flag) {
+  const i = argv.indexOf(flag);
+  if (i === -1) return false;
+  argv.splice(i, 1);
+  return true;
+}
+
+const entry = process.env.MODWRIGHT_ENTRY ?? path.join(repoRoot, "dist", "index.js");
+const env = { ...getDefaultEnvironment(), MODWRIGHT_NO_HOT_RELOAD: "1" };
+for (const [key, value] of Object.entries(process.env)) {
+  if (key.startsWith("MODWRIGHT_") && value !== undefined) env[key] = value;
+}
+
+const client = new Client({ name: "modwright-tool-cli", version: "1.0.0" });
+const transport = new StdioClientTransport({ command: process.execPath, args: [entry], env, stderr: "inherit" });
+
+try {
+  await client.connect(transport);
+  if (command === "list") {
+    const withSchemas = takeSwitch("--schemas");
+    const { tools } = await client.listTools();
+    tools.sort((a, b) => a.name.localeCompare(b.name));
+    if (withSchemas) {
+      process.stdout.write(`${JSON.stringify(tools, null, 2)}\n`);
+    } else {
+      for (const t of tools) {
+        const params = Object.keys(t.inputSchema?.properties ?? {}).join(", ");
+        process.stdout.write(`${t.name}${params ? `  (${params})` : ""}\n`);
+      }
+    }
+  } else if (command === "prompts") {
+    const { prompts } = await client.listPrompts();
+    for (const p of prompts) process.stdout.write(`${p.name}  ${p.description ?? ""}\n`);
+  } else if (command === "prompt") {
+    const outFile = takeFlag("--out");
+    const name = argv.shift();
+    if (!name) {
+      usage();
+      process.exit(2);
+    }
+    const promptArgs = {};
+    for (const pair of argv) {
+      const eq = pair.indexOf("=");
+      if (eq <= 0) {
+        process.stderr.write(`mw-tool: expected key=value, got "${pair}"\n`);
+        process.exit(2);
+      }
+      promptArgs[pair.slice(0, eq)] = pair.slice(eq + 1);
+    }
+    const result = await client.getPrompt({ name, arguments: promptArgs });
+    const text = (result.messages ?? [])
+      .map((m) => (m.content?.type === "text" ? m.content.text : `[${m.content?.type} content]`))
+      .join("\n\n");
+    if (outFile) {
+      await fs.writeFile(outFile, `${text}\n`, "utf8");
+      process.stderr.write(`mw-tool: wrote ${outFile}\n`);
+    } else {
+      process.stdout.write(`${text}\n`);
+    }
+  } else {
+    const outFile = takeFlag("--out");
+    const argsFile = takeFlag("--args-file");
+    const jsonArgs = takeFlag("--json");
+    const tool = argv.shift();
+    if (!tool) {
+      usage();
+      process.exit(2);
+    }
+    let args = {};
+    if (argsFile) Object.assign(args, JSON.parse(await fs.readFile(argsFile, "utf8")));
+    if (jsonArgs) Object.assign(args, JSON.parse(jsonArgs));
+    for (const pair of argv) {
+      const eq = pair.indexOf("=");
+      if (eq <= 0) {
+        process.stderr.write(`mw-tool: expected key=value, got "${pair}"\n`);
+        process.exit(2);
+      }
+      const key = pair.slice(0, eq);
+      const raw = pair.slice(eq + 1);
+      args[key] = parseValue(raw);
+    }
+    const result = await client.callTool({ name: tool, arguments: args }, undefined, { timeout: REQUEST_TIMEOUT_MS, resetTimeoutOnProgress: true });
+    const text = (result.content ?? [])
+      .map((c) => (c.type === "text" ? c.text : `[${c.type} content]`))
+      .join("\n");
+    const pretty = prettify(text);
+    if (outFile) {
+      await fs.writeFile(outFile, `${pretty}\n`, "utf8");
+      process.stderr.write(`mw-tool: wrote ${outFile}\n`);
+    } else {
+      process.stdout.write(`${pretty}\n`);
+    }
+    if (result.isError) process.exitCode = 1;
+  }
+} catch (error) {
+  process.stderr.write(`mw-tool: ${error?.message ?? error}\n`);
+  process.exitCode = 1;
+} finally {
+  await client.close().catch(() => {});
+}
+
+function parseValue(raw) {
+  if (raw === "") return "";
+  const first = raw[0];
+  if (first === "{" || first === "[" || first === '"' || raw === "true" || raw === "false" || raw === "null" || /^-?\d+(\.\d+)?$/.test(raw)) {
+    try {
+      return JSON.parse(raw);
+    } catch {
+      return raw;
+    }
+  }
+  return raw;
+}
+
+function prettify(text) {
+  try {
+    return JSON.stringify(JSON.parse(text), null, 2);
+  } catch {
+    return text;
+  }
+}