@julong/mono-rele2-utils 1.3.1 → 1.4.0

package/README.md

@@ -36,40 +36,41 @@ Available skills:
 
 ### Skills
 
-#### `caseConvertTool`
+<!-- SKILLS:START -->
 
-Converts text to the specified case format.
+#### `cnTool`
+
+Merges class names, filtering out falsy values.
 
 ```sh
-mono-rele2-utils caseConvertTool <input> <to>
+mono-rele2-utils cnTool <classes>
 ```
 
 | arg | type | description |
 |-----|------|-------------|
-| `input` | string | Text to convert |
-| `to` | `upper` \| `lower` \| `capitalize` \| `camel` \| `snake` \| `kebab` | Target case format |
+| `classes` | JSON string (array) | List of class names to merge |
 
 ```sh
-mono-rele2-utils caseConvertTool "hello world" camel     # helloWorld
-mono-rele2-utils caseConvertTool "helloWorld" snake      # hello_world
-mono-rele2-utils caseConvertTool "hello world" kebab     # hello-world
-mono-rele2-utils caseConvertTool "hello world" upper     # HELLO WORLD
+mono-rele2-utils cnTool '["btn","active","large"]'    # btn active large
 ```
 
-#### `cnTool`
+#### `caseConvertTool`
 
-Merges class names, filtering out falsy values.
+Converts text to the specified case format.
 
 ```sh
-mono-rele2-utils cnTool <classes>
+mono-rele2-utils caseConvertTool <input> <to>
 ```
 
 | arg | type | description |
 |-----|------|-------------|
-| `classes` | JSON string (array) | Class names to merge |
+| `input` | string | Text to convert |
+| `to` | `upper` \| `lower` \| `capitalize` \| `camel` \| `snake` \| `kebab` | Target case format |
 
 ```sh
-mono-rele2-utils cnTool '["btn", "active", "large"]'    # btn active large
+mono-rele2-utils caseConvertTool "hello world" camel    # helloWorld
+mono-rele2-utils caseConvertTool "helloWorld" snake     # hello_world
+mono-rele2-utils caseConvertTool "hello world" kebab    # hello-world
 ```
 
 #### `truncateTool`
@@ -84,13 +85,15 @@ mono-rele2-utils truncateTool <input> <maxLength> [suffix]
 |-----|------|-------------|
 | `input` | string | Text to truncate |
 | `maxLength` | number | Maximum character length |
-| `suffix` | string | Suffix to append (default: `...`) |
+| `suffix` | string | Suffix to append when truncated (default: `...`) |
 
 ```sh
 mono-rele2-utils truncateTool "hello world long text" 10    # hello w...
 mono-rele2-utils truncateTool "hello world" 8 "…"           # hello w…
 ```
 
+<!-- SKILLS:END -->
+
 ## MCP Server
 
 ```sh

package/dist/cli.js

@@ -1,6 +1,6 @@
 #!/usr/bin/env node
 
-// ../common/mcp/tool.ts
+// ../common/kit/tool.ts
 function toolDef(def) {
   return def;
 }
@@ -11,11 +11,11 @@ function text(content) {
   return { content: [{ type: "text", text: content }] };
 }
 
-// ../common/mcp/server.ts
+// ../common/kit/server.ts
 import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
 import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
 
-// ../common/mcp/cli.ts
+// ../common/kit/cli.ts
 import { z } from "zod";
 function formatSkills(tools2) {
   const sections = Object.entries(tools2).map(([key, tool]) => {
@@ -66,9 +66,12 @@ function handleCliError(err) {
   process.exit(1);
 }
 
-// src/tools/text.ts
+// ../common/kit/skill.ts
 import { z as z2 } from "zod";
 
+// src/tools/text.ts
+import { z as z3 } from "zod";
+
 // src/cn.ts
 function cn(...classes) {
   return classes.filter(Boolean).join(" ");
@@ -80,31 +83,43 @@ var tools = {
     name: "cn",
     description: "Merges class names, filtering out falsy values",
     inputSchema: {
-      classes: z2.array(z2.string()).describe("List of class names to merge")
+      classes: z3.array(z3.string()).describe("List of class names to merge")
     },
-    handler: async ({ classes }) => text(cn(...classes))
+    handler: async ({ classes }) => text(cn(...classes)),
+    examples: [
+      { args: [`'["btn","active","large"]'`], result: "btn active large" }
+    ]
   }),
   caseConvertTool: toolDef({
     name: "case_convert",
     description: "Converts text to the specified case format",
     inputSchema: {
-      input: z2.string().describe("Text to convert"),
-      to: z2.enum(["upper", "lower", "capitalize", "camel", "snake", "kebab"]).describe("Target case format")
+      input: z3.string().describe("Text to convert"),
+      to: z3.enum(["upper", "lower", "capitalize", "camel", "snake", "kebab"]).describe("Target case format")
     },
-    handler: async ({ input, to }) => text(convert(input, to))
+    handler: async ({ input, to }) => text(convert(input, to)),
+    examples: [
+      { args: [`"hello world"`, "camel"], result: "helloWorld" },
+      { args: [`"helloWorld"`, "snake"], result: "hello_world" },
+      { args: [`"hello world"`, "kebab"], result: "hello-world" }
+    ]
   }),
   truncateTool: toolDef({
     name: "truncate",
     description: "Truncates text to a maximum length and appends a suffix",
     inputSchema: {
-      input: z2.string().describe("Text to truncate"),
-      maxLength: z2.number().int().positive().describe("Maximum character length"),
-      suffix: z2.string().default("...").describe("Suffix to append when truncated")
+      input: z3.string().describe("Text to truncate"),
+      maxLength: z3.number().int().positive().describe("Maximum character length"),
+      suffix: z3.string().default("...").describe("Suffix to append when truncated")
     },
     handler: async ({ input, maxLength, suffix }) => {
       const result = input.length <= maxLength ? input : input.slice(0, maxLength - suffix.length) + suffix;
       return text(result);
-    }
+    },
+    examples: [
+      { args: [`"hello world long text"`, "10"], result: "hello w..." },
+      { args: [`"hello world"`, "8", `"\u2026"`], result: "hello w\u2026" }
+    ]
   })
 };
 var cnTool = defineTool(tools.cnTool);

package/dist/index.d.ts

@@ -1,7 +1,86 @@
 import * as _modelcontextprotocol_sdk_server_mcp_js from '@modelcontextprotocol/sdk/server/mcp.js';
+import { CallToolResult } from '@modelcontextprotocol/sdk/types.js';
+import { z } from 'zod';
 
 declare function cn(...classes: (string | undefined | null | false)[]): string;
 
+type ToolResult = CallToolResult;
+type ToolExample = {
+    args: string[];
+    result: string;
+};
+type AnyToolDef = {
+    name: string;
+    description: string;
+    inputSchema: z.ZodRawShape;
+    handler: (args: any) => Promise<ToolResult>;
+    examples?: ToolExample[];
+    guidelines?: string[];
+};
+
+type SkillTools = Record<string, AnyToolDef>;
+declare function generateSkillMarkdown(opts: {
+    binName: string;
+    description: string;
+    tools: SkillTools;
+}): string;
+declare function generateReadmeSkills(opts: {
+    binName: string;
+    tools: SkillTools;
+}): string;
+
+declare const tools: {
+    cnTool: {
+        name: string;
+        description: string;
+        inputSchema: {
+            readonly classes: z.ZodArray<z.ZodString>;
+        };
+        handler: (input: {
+            classes: string[];
+        }) => Promise<ToolResult>;
+        examples?: ToolExample[];
+        guidelines?: string[];
+    };
+    caseConvertTool: {
+        name: string;
+        description: string;
+        inputSchema: {
+            readonly input: z.ZodString;
+            readonly to: z.ZodEnum<{
+                upper: "upper";
+                lower: "lower";
+                capitalize: "capitalize";
+                camel: "camel";
+                snake: "snake";
+                kebab: "kebab";
+            }>;
+        };
+        handler: (input: {
+            input: string;
+            to: "upper" | "lower" | "capitalize" | "camel" | "snake" | "kebab";
+        }) => Promise<ToolResult>;
+        examples?: ToolExample[];
+        guidelines?: string[];
+    };
+    truncateTool: {
+        name: string;
+        description: string;
+        inputSchema: {
+            readonly input: z.ZodString;
+            readonly maxLength: z.ZodNumber;
+            readonly suffix: z.ZodDefault<z.ZodString>;
+        };
+        handler: (input: {
+            input: string;
+            maxLength: number;
+            suffix: string;
+        }) => Promise<ToolResult>;
+        examples?: ToolExample[];
+        guidelines?: string[];
+    };
+};
+
 declare function createUtilsServer(): _modelcontextprotocol_sdk_server_mcp_js.McpServer;
 
-export { cn, createUtilsServer };
+export { cn, createUtilsServer, generateReadmeSkills, generateSkillMarkdown, tools };

package/dist/index.js

@@ -1,4 +1,4 @@
-// ../common/mcp/tool.ts
+// ../common/kit/tool.ts
 function toolDef(def) {
   return def;
 }
@@ -9,7 +9,7 @@ function text(content) {
   return { content: [{ type: "text", text: content }] };
 }
 
-// ../common/mcp/server.ts
+// ../common/kit/server.ts
 import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
 import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
 function createMcpServer(config, tools2) {
@@ -25,11 +25,190 @@ function createMcpServer(config, tools2) {
   return server;
 }
 
-// ../common/mcp/cli.ts
+// ../common/kit/cli.ts
 import { z } from "zod";
 
-// src/tools/text.ts
+// ../common/kit/skill.ts
 import { z as z2 } from "zod";
+function generateSkillMarkdown(opts) {
+  const { binName, description, tools: tools2 } = opts;
+  return `---
+name: ${binName}
+description: ${description}
+---
+
+# ${binName}
+
+\`\`\`sh
+${binName} <skillName> [...args]
+\`\`\`
+
+## Skills
+
+${renderSkills(tools2)}
+
+## Examples
+
+${renderExamples(binName, tools2)}
+
+## Guidelines
+
+${renderGuidelines(binName, tools2)}
+`;
+}
+function renderSkills(tools2) {
+  return Object.entries(tools2).map(([key, tool]) => {
+    const rows = Object.entries(tool.inputSchema).map(([field, schema]) => `| \`${field}\` | ${describeField(schema)} |`).join("\n");
+    return `### ${key}
+
+${tool.description}
+
+| arg | description |
+|-----|-------------|
+${rows}`;
+  }).join("\n\n");
+}
+function describeField(schema) {
+  const baseDesc = schema.description ?? "";
+  let inner = schema;
+  let defaultValue;
+  let isOptional = false;
+  while (inner instanceof z2.ZodOptional || inner instanceof z2.ZodDefault) {
+    if (inner instanceof z2.ZodDefault) {
+      const raw = inner.def.defaultValue;
+      defaultValue = typeof raw === "function" ? raw() : raw;
+    }
+    if (inner instanceof z2.ZodOptional) isOptional = true;
+    inner = inner.unwrap();
+  }
+  const parts = [];
+  if (baseDesc) parts.push(baseDesc);
+  if (inner instanceof z2.ZodEnum) {
+    const values = inner.options.map((v) => `\`${v}\``).join(" \\| ");
+    parts.push(values);
+  }
+  if (defaultValue !== void 0) parts.push(`default: \`${String(defaultValue)}\``);
+  else if (isOptional) parts.push("optional");
+  return parts.join(" \u2014 ");
+}
+function renderExamples(binName, tools2) {
+  const lines = [];
+  for (const [key, tool] of Object.entries(tools2)) {
+    if (!tool.examples) continue;
+    for (const ex of tool.examples) {
+      const cmd = [binName, key, ...ex.args].join(" ");
+      lines.push(`- \`${cmd}\` \u2192 \`${ex.result}\``);
+    }
+  }
+  return lines.join("\n");
+}
+function renderGuidelines(binName, tools2) {
+  const items = [];
+  const seen = /* @__PURE__ */ new Set();
+  const push = (g) => {
+    if (seen.has(g)) return;
+    seen.add(g);
+    items.push(g);
+  };
+  push("Arguments are positional \u2014 pass them in the order listed in each skill's table");
+  const allSchemas = Object.values(tools2).flatMap((t) => Object.values(t.inputSchema));
+  if (allSchemas.some((s) => containsType(s, z2.ZodNumber))) {
+    push("Numeric args are auto-parsed \u2014 pass as plain numbers (e.g. `10`)");
+  }
+  if (allSchemas.some((s) => containsType(s, z2.ZodArray))) {
+    push('Array args must be valid JSON \u2014 wrap in single quotes on Unix shells (e.g. `\'["a","b"]\'`)');
+  }
+  if (allSchemas.some((s) => s instanceof z2.ZodOptional || s instanceof z2.ZodDefault)) {
+    push("Optional args with defaults may be omitted");
+  }
+  for (const tool of Object.values(tools2)) {
+    if (!tool.guidelines) continue;
+    for (const g of tool.guidelines) push(g);
+  }
+  push(`Run \`${binName}\` with no args to list all available skills`);
+  return items.map((g) => `- ${g}`).join("\n");
+}
+function containsType(schema, ctor) {
+  let inner = schema;
+  while (inner instanceof z2.ZodOptional || inner instanceof z2.ZodDefault) {
+    inner = inner.unwrap();
+  }
+  return inner instanceof ctor;
+}
+function generateReadmeSkills(opts) {
+  const { binName, tools: tools2 } = opts;
+  return Object.entries(tools2).map(([key, tool]) => renderReadmeSkill(binName, key, tool)).join("\n\n");
+}
+function renderReadmeSkill(binName, key, tool) {
+  const fields = Object.entries(tool.inputSchema);
+  const usageArgs = fields.map(([field, schema]) => {
+    const isOpt = schema instanceof z2.ZodOptional || schema instanceof z2.ZodDefault;
+    return isOpt ? `[${field}]` : `<${field}>`;
+  }).join(" ");
+  const usage = [binName, key, usageArgs].filter(Boolean).join(" ");
+  const rows = fields.map(([field, schema]) => {
+    const t = describeReadmeType(schema);
+    const d = describeReadmeDesc(schema);
+    return `| \`${field}\` | ${t} | ${d} |`;
+  }).join("\n");
+  const examples = tool.examples ?? [];
+  let exampleBlock = "";
+  if (examples.length > 0) {
+    const cmds = examples.map((ex) => [binName, key, ...ex.args].join(" "));
+    const width = Math.max(...cmds.map((c) => c.length));
+    const lines = examples.map((ex, i) => `${cmds[i].padEnd(width)}    # ${ex.result}`);
+    exampleBlock = `
+
+\`\`\`sh
+${lines.join("\n")}
+\`\`\``;
+  }
+  return `#### \`${key}\`
+
+${tool.description}.
+
+\`\`\`sh
+${usage}
+\`\`\`
+
+| arg | type | description |
+|-----|------|-------------|
+${rows}${exampleBlock}`;
+}
+function describeReadmeType(schema) {
+  let inner = schema;
+  while (inner instanceof z2.ZodOptional || inner instanceof z2.ZodDefault) {
+    inner = inner.unwrap();
+  }
+  if (inner instanceof z2.ZodEnum) {
+    return inner.options.map((v) => `\`${v}\``).join(" \\| ");
+  }
+  if (inner instanceof z2.ZodNumber) return "number";
+  if (inner instanceof z2.ZodString) return "string";
+  if (inner instanceof z2.ZodBoolean) return "boolean";
+  if (inner instanceof z2.ZodArray) return "JSON string (array)";
+  return "unknown";
+}
+function describeReadmeDesc(schema) {
+  const baseDesc = schema.description ?? "";
+  let inner = schema;
+  let defaultValue;
+  let isOptional = false;
+  while (inner instanceof z2.ZodOptional || inner instanceof z2.ZodDefault) {
+    if (inner instanceof z2.ZodDefault) {
+      const raw = inner.def.defaultValue;
+      defaultValue = typeof raw === "function" ? raw() : raw;
+    }
+    if (inner instanceof z2.ZodOptional) isOptional = true;
+    inner = inner.unwrap();
+  }
+  if (defaultValue !== void 0) return `${baseDesc} (default: \`${String(defaultValue)}\`)`;
+  if (isOptional) return `${baseDesc} (optional)`;
+  return baseDesc;
+}
+
+// src/tools/text.ts
+import { z as z3 } from "zod";
 
 // src/cn.ts
 function cn(...classes) {
@@ -42,31 +221,43 @@ var tools = {
     name: "cn",
     description: "Merges class names, filtering out falsy values",
     inputSchema: {
-      classes: z2.array(z2.string()).describe("List of class names to merge")
+      classes: z3.array(z3.string()).describe("List of class names to merge")
     },
-    handler: async ({ classes }) => text(cn(...classes))
+    handler: async ({ classes }) => text(cn(...classes)),
+    examples: [
+      { args: [`'["btn","active","large"]'`], result: "btn active large" }
+    ]
   }),
   caseConvertTool: toolDef({
     name: "case_convert",
     description: "Converts text to the specified case format",
     inputSchema: {
-      input: z2.string().describe("Text to convert"),
-      to: z2.enum(["upper", "lower", "capitalize", "camel", "snake", "kebab"]).describe("Target case format")
+      input: z3.string().describe("Text to convert"),
+      to: z3.enum(["upper", "lower", "capitalize", "camel", "snake", "kebab"]).describe("Target case format")
     },
-    handler: async ({ input, to }) => text(convert(input, to))
+    handler: async ({ input, to }) => text(convert(input, to)),
+    examples: [
+      { args: [`"hello world"`, "camel"], result: "helloWorld" },
+      { args: [`"helloWorld"`, "snake"], result: "hello_world" },
+      { args: [`"hello world"`, "kebab"], result: "hello-world" }
+    ]
   }),
   truncateTool: toolDef({
     name: "truncate",
     description: "Truncates text to a maximum length and appends a suffix",
     inputSchema: {
-      input: z2.string().describe("Text to truncate"),
-      maxLength: z2.number().int().positive().describe("Maximum character length"),
-      suffix: z2.string().default("...").describe("Suffix to append when truncated")
+      input: z3.string().describe("Text to truncate"),
+      maxLength: z3.number().int().positive().describe("Maximum character length"),
+      suffix: z3.string().default("...").describe("Suffix to append when truncated")
     },
     handler: async ({ input, maxLength, suffix }) => {
       const result = input.length <= maxLength ? input : input.slice(0, maxLength - suffix.length) + suffix;
       return text(result);
-    }
+    },
+    examples: [
+      { args: [`"hello world long text"`, "10"], result: "hello w..." },
+      { args: [`"hello world"`, "8", `"\u2026"`], result: "hello w\u2026" }
+    ]
   })
 };
 var cnTool = defineTool(tools.cnTool);
@@ -98,5 +289,8 @@ function createUtilsServer() {
 }
 export {
   cn,
-  createUtilsServer
+  createUtilsServer,
+  generateReadmeSkills,
+  generateSkillMarkdown,
+  tools
 };

package/dist/server.js

@@ -1,6 +1,6 @@
 #!/usr/bin/env node
 
-// ../common/mcp/tool.ts
+// ../common/kit/tool.ts
 function toolDef(def) {
   return def;
 }
@@ -11,7 +11,7 @@ function text(content) {
   return { content: [{ type: "text", text: content }] };
 }
 
-// ../common/mcp/server.ts
+// ../common/kit/server.ts
 import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
 import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
 function createMcpServer(config, tools2) {
@@ -31,12 +31,15 @@ async function startServer(server2) {
   await server2.connect(transport);
 }
 
-// ../common/mcp/cli.ts
+// ../common/kit/cli.ts
 import { z } from "zod";
 
-// src/tools/text.ts
+// ../common/kit/skill.ts
 import { z as z2 } from "zod";
 
+// src/tools/text.ts
+import { z as z3 } from "zod";
+
 // src/cn.ts
 function cn(...classes) {
   return classes.filter(Boolean).join(" ");
@@ -48,31 +51,43 @@ var tools = {
     name: "cn",
     description: "Merges class names, filtering out falsy values",
     inputSchema: {
-      classes: z2.array(z2.string()).describe("List of class names to merge")
+      classes: z3.array(z3.string()).describe("List of class names to merge")
     },
-    handler: async ({ classes }) => text(cn(...classes))
+    handler: async ({ classes }) => text(cn(...classes)),
+    examples: [
+      { args: [`'["btn","active","large"]'`], result: "btn active large" }
+    ]
   }),
   caseConvertTool: toolDef({
     name: "case_convert",
     description: "Converts text to the specified case format",
     inputSchema: {
-      input: z2.string().describe("Text to convert"),
-      to: z2.enum(["upper", "lower", "capitalize", "camel", "snake", "kebab"]).describe("Target case format")
+      input: z3.string().describe("Text to convert"),
+      to: z3.enum(["upper", "lower", "capitalize", "camel", "snake", "kebab"]).describe("Target case format")
     },
-    handler: async ({ input, to }) => text(convert(input, to))
+    handler: async ({ input, to }) => text(convert(input, to)),
+    examples: [
+      { args: [`"hello world"`, "camel"], result: "helloWorld" },
+      { args: [`"helloWorld"`, "snake"], result: "hello_world" },
+      { args: [`"hello world"`, "kebab"], result: "hello-world" }
+    ]
   }),
   truncateTool: toolDef({
     name: "truncate",
     description: "Truncates text to a maximum length and appends a suffix",
     inputSchema: {
-      input: z2.string().describe("Text to truncate"),
-      maxLength: z2.number().int().positive().describe("Maximum character length"),
-      suffix: z2.string().default("...").describe("Suffix to append when truncated")
+      input: z3.string().describe("Text to truncate"),
+      maxLength: z3.number().int().positive().describe("Maximum character length"),
+      suffix: z3.string().default("...").describe("Suffix to append when truncated")
     },
     handler: async ({ input, maxLength, suffix }) => {
       const result = input.length <= maxLength ? input : input.slice(0, maxLength - suffix.length) + suffix;
       return text(result);
-    }
+    },
+    examples: [
+      { args: [`"hello world long text"`, "10"], result: "hello w..." },
+      { args: [`"hello world"`, "8", `"\u2026"`], result: "hello w\u2026" }
+    ]
   })
 };
 var cnTool = defineTool(tools.cnTool);

package/dist/{mono-rele2-utils → skills/mono-rele2-utils}/skill.md

@@ -5,54 +5,52 @@ description: Use this skill to invoke text utility functions via the mono-rele2-
 
 # mono-rele2-utils
 
-CLI for running text utility functions from the mono-rele2 package.
-
 ```sh
 mono-rele2-utils <skillName> [...args]
 ```
 
 ## Skills
 
-### caseConvertTool
+### cnTool
 
-Converts text to the specified case format.
+Merges class names, filtering out falsy values
 
 | arg | description |
 |-----|-------------|
-| `input` | Text to convert |
-| `to` | Target format: `upper` \| `lower` \| `capitalize` \| `camel` \| `snake` \| `kebab` |
+| `classes` | List of class names to merge |
 
-### cnTool
+### caseConvertTool
 
-Merges class names, filtering out falsy values.
+Converts text to the specified case format
 
 | arg | description |
 |-----|-------------|
-| `classes` | JSON array of class name strings, e.g. `'["btn","active"]'` |
+| `input` | Text to convert |
+| `to` | Target case format — `upper` \| `lower` \| `capitalize` \| `camel` \| `snake` \| `kebab` |
 
 ### truncateTool
 
-Truncates text to a maximum length and appends a suffix.
+Truncates text to a maximum length and appends a suffix
 
 | arg | description |
 |-----|-------------|
 | `input` | Text to truncate |
 | `maxLength` | Maximum character length |
-| `suffix` | Suffix to append when truncated (default: `...`) |
+| `suffix` | Suffix to append when truncated — default: `...` |
 
 ## Examples
 
+- `mono-rele2-utils cnTool '["btn","active","large"]'` → `btn active large`
 - `mono-rele2-utils caseConvertTool "hello world" camel` → `helloWorld`
 - `mono-rele2-utils caseConvertTool "helloWorld" snake` → `hello_world`
 - `mono-rele2-utils caseConvertTool "hello world" kebab` → `hello-world`
 - `mono-rele2-utils truncateTool "hello world long text" 10` → `hello w...`
 - `mono-rele2-utils truncateTool "hello world" 8 "…"` → `hello w…`
-- `mono-rele2-utils cnTool '["btn","active","large"]'` → `btn active large`
 
 ## Guidelines
 
 - Arguments are positional — pass them in the order listed in each skill's table
-- Numeric args (e.g. `maxLength`) are auto-parsed — pass as plain numbers: `10`
-- Array args (e.g. `classes`) must be valid JSON — wrap in single quotes on Unix shells
-- Optional args with defaults (e.g. `suffix`) may be omitted
+- Numeric args are auto-parsed — pass as plain numbers (e.g. `10`)
+- Array args must be valid JSON — wrap in single quotes on Unix shells (e.g. `'["a","b"]'`)
+- Optional args with defaults may be omitted
 - Run `mono-rele2-utils` with no args to list all available skills

package/package.json

@@ -1,6 +1,7 @@
 {
   "name": "@julong/mono-rele2-utils",
-  "version": "1.3.1",
+  "version": "1.4.0",
+  "description": "Use this skill to invoke text utility functions via the mono-rele2-utils CLI. Handles class name merging, case conversion, and text truncation.",
   "license": "ISC",
   "type": "module",
   "exports": {
@@ -22,7 +23,8 @@
   "scripts": {
     "build": "tsup",
     "typecheck": "tsc --noEmit",
-    "clean": "rimraf dist"
+    "clean": "rimraf dist",
+    "update-readme": "node ../common/build/update-readme.mjs"
   },
   "dependencies": {
     "@modelcontextprotocol/sdk": "^1.29.0",