@julong/mono-rele2-utils 1.2.0 → 1.3.0

package/dist/cli.js

@@ -0,0 +1,131 @@
+#!/usr/bin/env node
+
+// ../common/mcp/tool.ts
+function toolDef(def) {
+  return def;
+}
+function defineTool(tool) {
+  return tool;
+}
+function text(content) {
+  return { content: [{ type: "text", text: content }] };
+}
+
+// ../common/mcp/server.ts
+import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
+import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
+
+// ../common/mcp/cli.ts
+import { z } from "zod";
+function formatSkills(tools2) {
+  const sections = Object.entries(tools2).map(([key, tool]) => {
+    const params = Object.entries(tool.inputSchema);
+    const maxLen = Math.max(...params.map(([f]) => f.length));
+    const paramLines = params.map(([field, schema]) => {
+      const desc = schema.description ?? "";
+      return `    ${field.padEnd(maxLen + 2)}${desc}`;
+    }).join("\n");
+    return `  ${key}
+  ${tool.description}
+${paramLines}`;
+  });
+  return "Available skills:\n\n" + sections.join("\n\n");
+}
+async function runCli(tools2) {
+  const [, , toolName, ...rawArgs] = process.argv;
+  if (!toolName || !(toolName in tools2)) {
+    if (toolName) console.error(`Unknown skill: "${toolName}"
+`);
+    console.log(formatSkills(tools2));
+    process.exit(toolName ? 1 : 0);
+  }
+  const tool = tools2[toolName];
+  const fieldNames = Object.keys(tool.inputSchema);
+  const rawInput = {};
+  for (let i = 0; i < fieldNames.length; i++) {
+    const raw = rawArgs[i];
+    if (raw === void 0) continue;
+    try {
+      rawInput[fieldNames[i]] = JSON.parse(raw);
+    } catch {
+      rawInput[fieldNames[i]] = raw;
+    }
+  }
+  const parsed = z.object(tool.inputSchema).parse(rawInput);
+  const result = await tool.handler(parsed);
+  for (const part of result.content) {
+    if (part.type === "text") console.log(part.text);
+  }
+}
+function handleCliError(err) {
+  if (err instanceof z.ZodError) {
+    console.error("Validation error:", err.issues.map((e) => `${e.path.join(".")}: ${e.message}`).join(", "));
+  } else {
+    console.error("Error:", err instanceof Error ? err.message : String(err));
+  }
+  process.exit(1);
+}
+
+// src/tools/text.ts
+import { z as z2 } from "zod";
+
+// src/cn.ts
+function cn(...classes) {
+  return classes.filter(Boolean).join(" ");
+}
+
+// src/tools/text.ts
+var tools = {
+  cnTool: toolDef({
+    name: "cn",
+    description: "Merges class names, filtering out falsy values",
+    inputSchema: {
+      classes: z2.array(z2.string()).describe("List of class names to merge")
+    },
+    handler: async ({ classes }) => text(cn(...classes))
+  }),
+  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")
+    },
+    handler: async ({ input, to }) => text(convert(input, to))
+  }),
+  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")
+    },
+    handler: async ({ input, maxLength, suffix }) => {
+      const result = input.length <= maxLength ? input : input.slice(0, maxLength - suffix.length) + suffix;
+      return text(result);
+    }
+  })
+};
+var cnTool = defineTool(tools.cnTool);
+var caseConvertTool = defineTool(tools.caseConvertTool);
+var truncateTool = defineTool(tools.truncateTool);
+function convert(input, to) {
+  switch (to) {
+    case "upper":
+      return input.toUpperCase();
+    case "lower":
+      return input.toLowerCase();
+    case "capitalize":
+      return input.charAt(0).toUpperCase() + input.slice(1).toLowerCase();
+    case "camel":
+      return input.replace(/[-_\s]+(.)/g, (_, c) => c.toUpperCase()).replace(/^(.)/, (c) => c.toLowerCase());
+    case "snake":
+      return input.replace(/([A-Z])/g, "_$1").replace(/[-\s]+/g, "_").toLowerCase().replace(/^_/, "");
+    case "kebab":
+      return input.replace(/([A-Z])/g, "-$1").replace(/[_\s]+/g, "-").toLowerCase().replace(/^-/, "");
+  }
+}
+
+// src/cli.ts
+runCli(tools).catch(handleCliError);

package/dist/index.js

@@ -1,4 +1,7 @@
 // ../common/mcp/tool.ts
+function toolDef(def) {
+  return def;
+}
 function defineTool(tool) {
   return tool;
 }
@@ -9,9 +12,9 @@ function text(content) {
 // ../common/mcp/server.ts
 import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
 import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
-function createMcpServer(config, tools) {
+function createMcpServer(config, tools2) {
   const server = new McpServer(config);
-  for (const tool of tools) {
+  for (const tool of tools2) {
     server.registerTool(
       tool.name,
       { description: tool.description, inputSchema: tool.inputSchema },
@@ -22,48 +25,53 @@ function createMcpServer(config, tools) {
   return server;
 }
 
-// src/tools/text.ts
+// ../common/mcp/cli.ts
 import { z } from "zod";
 
+// src/tools/text.ts
+import { z as z2 } from "zod";
+
 // src/cn.ts
 function cn(...classes) {
   return classes.filter(Boolean).join(" ");
 }
 
 // src/tools/text.ts
-var cnTool = defineTool({
-  name: "cn",
-  description: "Merges class names, filtering out falsy values",
-  inputSchema: {
-    classes: z.array(z.string()).describe("List of class names to merge")
-  },
-  handler: async ({ classes }) => text(cn(...classes))
-});
-var caseConvertTool = defineTool({
-  name: "case_convert",
-  description: "Converts text to the specified case format",
-  inputSchema: {
-    input: z.string().describe("Text to convert"),
-    to: z.enum(["upper", "lower", "capitalize", "camel", "snake", "kebab"]).describe("Target case format")
-  },
-  handler: async ({ input, to }) => {
-    const result = convert(input, to);
-    return text(result);
-  }
-});
-var truncateTool = defineTool({
-  name: "truncate",
-  description: "Truncates text to a maximum length and appends a suffix",
-  inputSchema: {
-    input: z.string().describe("Text to truncate"),
-    maxLength: z.number().int().positive().describe("Maximum character length"),
-    suffix: z.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);
-  }
-});
+var tools = {
+  cnTool: toolDef({
+    name: "cn",
+    description: "Merges class names, filtering out falsy values",
+    inputSchema: {
+      classes: z2.array(z2.string()).describe("List of class names to merge")
+    },
+    handler: async ({ classes }) => text(cn(...classes))
+  }),
+  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")
+    },
+    handler: async ({ input, to }) => text(convert(input, to))
+  }),
+  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")
+    },
+    handler: async ({ input, maxLength, suffix }) => {
+      const result = input.length <= maxLength ? input : input.slice(0, maxLength - suffix.length) + suffix;
+      return text(result);
+    }
+  })
+};
+var cnTool = defineTool(tools.cnTool);
+var caseConvertTool = defineTool(tools.caseConvertTool);
+var truncateTool = defineTool(tools.truncateTool);
 function convert(input, to) {
   switch (to) {
     case "upper":

package/dist/mono-rele2-utils/skill.md

@@ -0,0 +1,58 @@
+---
+name: mono-rele2-utils
+description: Use this skill to invoke text utility functions via the mono-rele2-utils CLI. Handles class name merging, case conversion, and text truncation.
+---
+
+# mono-rele2-utils
+
+CLI for running text utility functions from the mono-rele2 package.
+
+```sh
+mono-rele2-utils <skillName> [...args]
+```
+
+## Skills
+
+### caseConvertTool
+
+Converts text to the specified case format.
+
+| arg | description |
+|-----|-------------|
+| `input` | Text to convert |
+| `to` | Target format: `upper` \| `lower` \| `capitalize` \| `camel` \| `snake` \| `kebab` |
+
+### cnTool
+
+Merges class names, filtering out falsy values.
+
+| arg | description |
+|-----|-------------|
+| `classes` | JSON array of class name strings, e.g. `'["btn","active"]'` |
+
+### truncateTool
+
+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: `...`) |
+
+## Examples
+
+- `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
+- Run `mono-rele2-utils` with no args to list all available skills

package/dist/server.js

@@ -1,6 +1,9 @@
 #!/usr/bin/env node
 
 // ../common/mcp/tool.ts
+function toolDef(def) {
+  return def;
+}
 function defineTool(tool) {
   return tool;
 }
@@ -11,9 +14,9 @@ function text(content) {
 // ../common/mcp/server.ts
 import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
 import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
-function createMcpServer(config, tools) {
+function createMcpServer(config, tools2) {
   const server2 = new McpServer(config);
-  for (const tool of tools) {
+  for (const tool of tools2) {
     server2.registerTool(
       tool.name,
       { description: tool.description, inputSchema: tool.inputSchema },
@@ -28,48 +31,53 @@ async function startServer(server2) {
   await server2.connect(transport);
 }
 
-// src/tools/text.ts
+// ../common/mcp/cli.ts
 import { z } from "zod";
 
+// src/tools/text.ts
+import { z as z2 } from "zod";
+
 // src/cn.ts
 function cn(...classes) {
   return classes.filter(Boolean).join(" ");
 }
 
 // src/tools/text.ts
-var cnTool = defineTool({
-  name: "cn",
-  description: "Merges class names, filtering out falsy values",
-  inputSchema: {
-    classes: z.array(z.string()).describe("List of class names to merge")
-  },
-  handler: async ({ classes }) => text(cn(...classes))
-});
-var caseConvertTool = defineTool({
-  name: "case_convert",
-  description: "Converts text to the specified case format",
-  inputSchema: {
-    input: z.string().describe("Text to convert"),
-    to: z.enum(["upper", "lower", "capitalize", "camel", "snake", "kebab"]).describe("Target case format")
-  },
-  handler: async ({ input, to }) => {
-    const result = convert(input, to);
-    return text(result);
-  }
-});
-var truncateTool = defineTool({
-  name: "truncate",
-  description: "Truncates text to a maximum length and appends a suffix",
-  inputSchema: {
-    input: z.string().describe("Text to truncate"),
-    maxLength: z.number().int().positive().describe("Maximum character length"),
-    suffix: z.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);
-  }
-});
+var tools = {
+  cnTool: toolDef({
+    name: "cn",
+    description: "Merges class names, filtering out falsy values",
+    inputSchema: {
+      classes: z2.array(z2.string()).describe("List of class names to merge")
+    },
+    handler: async ({ classes }) => text(cn(...classes))
+  }),
+  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")
+    },
+    handler: async ({ input, to }) => text(convert(input, to))
+  }),
+  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")
+    },
+    handler: async ({ input, maxLength, suffix }) => {
+      const result = input.length <= maxLength ? input : input.slice(0, maxLength - suffix.length) + suffix;
+      return text(result);
+    }
+  })
+};
+var cnTool = defineTool(tools.cnTool);
+var caseConvertTool = defineTool(tools.caseConvertTool);
+var truncateTool = defineTool(tools.truncateTool);
 function convert(input, to) {
   switch (to) {
     case "upper":

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@julong/mono-rele2-utils",
-  "version": "1.2.0",
+  "version": "1.3.0",
   "license": "ISC",
   "type": "module",
   "exports": {
@@ -10,7 +10,8 @@
     }
   },
   "bin": {
-    "mcp-utils": "./dist/server.js"
+    "mcp-utils": "./dist/server.js",
+    "mono-rele2-utils": "./dist/cli.js"
   },
   "files": [
     "dist"