@julong/mono-rele2-utils 1.17.1 → 1.19.0

package/README.md

@@ -1,6 +1,6 @@
 # @julong/mono-rele2-utils
 
-Text utility tools for the mono-rele2 monorepo. Available as an MCP server and a standalone CLI.
+Use this skill to invoke text utility functions via the mono-rele2-utils CLI. Handles class name merging, case conversion, and text truncation.
 
 ## CLI
 
@@ -9,34 +9,22 @@ Text utility tools for the mono-rele2 monorepo. Available as an MCP server and a
 ```sh
 npm install -g @julong/mono-rele2-utils
 # or
-npx @julong/mono-rele2-utils-cli <skillName> [...args]
+npx @julong/mono-rele2-utils-cli <toolName> [...args]
 ```
 
 ### Usage
 
 ```sh
-mono-rele2-utils-cli <skillName> [...args]
+mono-rele2-utils-cli <toolName> [...args]
 ```
 
-Run without arguments to list all available skills:
+Run without arguments to list all available tools:
 
 ```sh
 mono-rele2-utils-cli
 ```
 
-```
-Available skills:
-
-  caseConvertTool
-  Converts text to the specified case format
-    input    Text to convert
-    to       Target case format
-  ...
-```
-
-### Skills
-
-<!-- SKILLS:START -->
+### Tools
 
 #### `cnTool`
 
@@ -92,7 +80,29 @@ mono-rele2-utils-cli truncateTool "hello world long text" 10    # hello w...
 mono-rele2-utils-cli truncateTool "hello world" 8 "…"           # hello w…
 ```
 
-<!-- SKILLS:END -->
+#### `objectFlattenTool`
+
+Flattens a nested JSON object of any depth into dot-notation key-value pairs. Accepts a JSON string and recursively flattens all levels. Arrays and primitives at any level are treated as leaf values..
+
+```sh
+mono-rele2-utils-cli objectFlattenTool <json>
+```
+
+| arg | type | description |
+|-----|------|-------------|
+| `json` | string | JSON string of a nested object to flatten (unlimited depth) |
+
+```sh
+mono-rele2-utils-cli objectFlattenTool '{"user":{"name":"Alice","address":{"city":"Seoul","zip":"12345"}},"active":true}'    # {
+  "user.name": "Alice",
+  "user.address.city": "Seoul",
+  "user.address.zip": "12345",
+  "active": true
+}
+mono-rele2-utils-cli objectFlattenTool '{"a":{"b":{"c":{"d":{"e":"deep"}}}}}'                                                # {
+  "a.b.c.d.e": "deep"
+}
+```
 
 ## MCP Server
 

package/dist/cli.js

@@ -1,145 +1,10 @@
 #!/usr/bin/env node
+function a(e){return{content:[{type:"text",text:e}]}}import{McpServer as R}from"@modelcontextprotocol/sdk/server/mcp.js";import{StdioServerTransport as N}from"@modelcontextprotocol/sdk/server/stdio.js";import{z as m}from"zod";function x(e){return`Available skills:
 
-// ../common/kit/tool.ts
-function toolDef(def) {
-  return def;
-}
-function defineTool(tool) {
-  return tool;
-}
-function text(content) {
-  return { content: [{ type: "text", text: content }] };
-}
+`+Object.entries(e).map(([o,t])=>{let r=Object.entries(t.inputSchema),i=Math.max(...r.map(([l])=>l.length)),p=r.map(([l,s])=>{let u=s.description??"";return`    ${l.padEnd(i+2)}${u}`}).join(`
+`);return`  ${o}
+  ${t.description}
+${p}`}).join(`
 
-// ../common/kit/server.ts
-import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
-import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
-
-// ../common/kit/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;
-  console.log(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);
-}
-
-// ../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(" ");
-}
-
-// src/tools/text.ts
-var tools = {
-  cnTool: toolDef({
-    name: "cn",
-    description: "Merges class names, filtering out falsy values",
-    inputSchema: {
-      classes: z3.array(z3.string()).describe("List of class names to merge")
-    },
-    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: 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)),
-    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: 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);
-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);
+`)}async function g(e){let[,,n,...o]=process.argv;console.log(process.argv),(!n||!(n in e))&&(n&&console.error(`Unknown skill: "${n}"
+`),console.log(x(e)),process.exit(n?1:0));let t=e[n],r=Object.keys(t.inputSchema),i={};for(let s=0;s<r.length;s++){let u=o[s];if(u!==void 0)try{i[r[s]]=JSON.parse(u)}catch{i[r[s]]=u}}let p=m.object(t.inputSchema).parse(i),l=await t.handler(p);for(let s of l.content)s.type==="text"&&console.log(s.text)}function y(e){e instanceof m.ZodError?console.error("Validation error:",e.issues.map(n=>`${n.path.join(".")}: ${n.message}`).join(", ")):console.error("Error:",e instanceof Error?e.message:String(e)),process.exit(1)}import{z as L}from"zod";import{z as c}from"zod";function h(...e){return e.filter(Boolean).join(" ")}var d={cnTool:{name:"cn",description:"Merges class names, filtering out falsy values",inputSchema:{classes:c.array(c.string()).describe("List of class names to merge")},handler:async({classes:e})=>a(h(...e)),examples:[{args:[`'["btn","active","large"]'`],result:"btn active large"}]},caseConvertTool:{name:"case_convert",description:"Converts text to the specified case format",inputSchema:{input:c.string().describe("Text to convert"),to:c.enum(["upper","lower","capitalize","camel","snake","kebab"]).describe("Target case format")},handler:async({input:e,to:n})=>a(j(e,n)),examples:[{args:['"hello world"',"camel"],result:"helloWorld"},{args:['"helloWorld"',"snake"],result:"hello_world"},{args:['"hello world"',"kebab"],result:"hello-world"}]},truncateTool:{name:"truncate",description:"Truncates text to a maximum length and appends a suffix",inputSchema:{input:c.string().describe("Text to truncate"),maxLength:c.number().int().positive().describe("Maximum character length"),suffix:c.string().default("...").describe("Suffix to append when truncated")},handler:async({input:e,maxLength:n,suffix:o})=>{let t=e.length<=n?e:e.slice(0,n-o.length)+o;return a(t)},examples:[{args:['"hello world long text"',"10"],result:"hello w..."},{args:['"hello world"',"8",'"\u2026"'],result:"hello w\u2026"}]}},w=d.cnTool,Z=d.caseConvertTool,A=d.truncateTool;function j(e,n){switch(n){case"upper":return e.toUpperCase();case"lower":return e.toLowerCase();case"capitalize":return e.charAt(0).toUpperCase()+e.slice(1).toLowerCase();case"camel":return e.replace(/[-_\s]+(.)/g,(o,t)=>t.toUpperCase()).replace(/^(.)/,o=>o.toLowerCase());case"snake":return e.replace(/([A-Z])/g,"_$1").replace(/[-\s]+/g,"_").toLowerCase().replace(/^_/,"");case"kebab":return e.replace(/([A-Z])/g,"-$1").replace(/[_\s]+/g,"-").toLowerCase().replace(/^-/,"")}}import{z}from"zod";function $(e){let n={};function o(t,r){if(t===null||typeof t!="object"||Array.isArray(t)){n[r]=t;return}for(let[i,p]of Object.entries(t)){let l=r?`${r}.${i}`:i;o(p,l)}}return o(e,""),n}var f={objectFlattenTool:{name:"object_flatten",description:"Flattens a nested JSON object of any depth into dot-notation key-value pairs. Accepts a JSON string and recursively flattens all levels. Arrays and primitives at any level are treated as leaf values.",inputSchema:{json:z.string().describe("JSON string of a nested object to flatten (unlimited depth)")},handler:async({json:e})=>{let n;try{let o=JSON.parse(e);if(typeof o!="object"||o===null||Array.isArray(o))return a(`Error: input must be a JSON object, got ${Array.isArray(o)?"array":typeof o}`);n=o}catch{return a("Error: invalid JSON string \u2014 unable to parse input")}try{let o=$(n);return a(JSON.stringify(o,null,2))}catch(o){return a(`Error: failed to flatten object \u2014 ${o.message}`)}},examples:[{args:[`'{"user":{"name":"Alice","address":{"city":"Seoul","zip":"12345"}},"active":true}'`],result:JSON.stringify({"user.name":"Alice","user.address.city":"Seoul","user.address.zip":"12345",active:!0},null,2)},{args:[`'{"a":{"b":{"c":{"d":{"e":"deep"}}}}}'`],result:JSON.stringify({"a.b.c.d.e":"deep"},null,2)}],guidelines:["Arrays and primitives at any level are always treated as leaf values \u2014 they are never traversed.","The result is always a flat JSON object with dot-notation keys.","There is no depth limit \u2014 objects of any nesting level are fully flattened."]}},k=f.objectFlattenTool;var T={...d,...f};g(T).catch(y);

package/dist/index.d.ts

@@ -1,4 +1,5 @@
 import { CallToolResult } from '@modelcontextprotocol/sdk/types.js';
+import * as zod from 'zod';
 import { z } from 'zod';
 
 declare function cn(...classes: (string | undefined | null | false)[]): string;
@@ -29,11 +30,23 @@ declare function generateReadmeSkills(opts: {
 }): string;
 
 declare const tools: {
+    objectFlattenTool: {
+        name: string;
+        description: string;
+        inputSchema: {
+            readonly json: zod.ZodString;
+        };
+        handler: (input: {
+            json: string;
+        }) => Promise<ToolResult>;
+        examples?: ToolExample[];
+        guidelines?: string[];
+    };
     cnTool: {
         name: string;
         description: string;
         inputSchema: {
-            readonly classes: z.ZodArray<z.ZodString>;
+            readonly classes: zod.ZodArray<zod.ZodString>;
         };
         handler: (input: {
             classes: string[];
@@ -45,8 +58,8 @@ declare const tools: {
         name: string;
         description: string;
         inputSchema: {
-            readonly input: z.ZodString;
-            readonly to: z.ZodEnum<{
+            readonly input: zod.ZodString;
+            readonly to: zod.ZodEnum<{
                 upper: "upper";
                 lower: "lower";
                 capitalize: "capitalize";
@@ -66,9 +79,9 @@ declare const tools: {
         name: string;
         description: string;
         inputSchema: {
-            readonly input: z.ZodString;
-            readonly maxLength: z.ZodNumber;
-            readonly suffix: z.ZodDefault<z.ZodString>;
+            readonly input: zod.ZodString;
+            readonly maxLength: zod.ZodNumber;
+            readonly suffix: zod.ZodDefault<zod.ZodString>;
         };
         handler: (input: {
             input: string;

package/dist/index.js

@@ -1,273 +1,52 @@
-// src/cn.ts
-function cn(...classes) {
-  return classes.filter(Boolean).join(" ");
-}
-
-// ../common/kit/tool.ts
-function toolDef(def) {
-  return def;
-}
-function defineTool(tool) {
-  return tool;
-}
-function text(content) {
-  return { content: [{ type: "text", text: content }] };
-}
-
-// ../common/kit/server.ts
-import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
-import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
-
-// ../common/kit/cli.ts
-import { z } from "zod";
-
-// ../common/kit/skill.ts
-import { z as z2 } from "zod";
-function generateSkillMarkdown(opts) {
-  const { binName, description, tools: tools2 } = opts;
-  return `---
-name: ${binName}
-description: ${description}
+function y(...o){return o.filter(Boolean).join(" ")}function c(o){return{content:[{type:"text",text:o}]}}import{McpServer as G}from"@modelcontextprotocol/sdk/server/mcp.js";import{StdioServerTransport as W}from"@modelcontextprotocol/sdk/server/stdio.js";import{z as K}from"zod";import{z as a}from"zod";function w(o){let{binName:n,description:e,tools:t}=o;return`---
+name: ${n}
+description: ${e}
 ---
 
-# ${binName}
+# ${n}
 
 \`\`\`sh
-${binName} <skillName> [...args]
+${n} <toolName> [...args]
 \`\`\`
 
 ## Skills
 
-${renderSkills(tools2)}
+${Z(t)}
 
 ## Examples
 
-${renderExamples(binName, tools2)}
+${j(n,t)}
 
 ## 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}
+${k(n,t)}
+`}function Z(o){return Object.entries(o).map(([n,e])=>{let t=Object.entries(e.inputSchema).map(([s,i])=>`| \`${s}\` | ${A(i)} |`).join(`
+`);return`### ${n}
 
-${tool.description}
+${e.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}\` => \`${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) {
-  console.log(opts.binName);
-  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 = `
+${t}`}).join(`
+
+`)}function A(o){let n=o.description??"",e=o,t,s=!1;for(;e instanceof a.ZodOptional||e instanceof a.ZodDefault;){if(e instanceof a.ZodDefault){let r=e.def.defaultValue;t=typeof r=="function"?r():r}e instanceof a.ZodOptional&&(s=!0),e=e.unwrap()}let i=[];if(n&&i.push(n),e instanceof a.ZodEnum){let r=e.options.map(l=>`\`${l}\``).join(" \\| ");i.push(r)}return t!==void 0?i.push(`default: \`${String(t)}\``):s&&i.push("optional"),i.join(" \u2014 ")}function j(o,n){let e=[];for(let[t,s]of Object.entries(n))if(s.examples)for(let i of s.examples){let r=[o,t,...i.args].join(" ");e.push(`- \`${r}\` => \`${i.result}\``)}return e.join(`
+`)}function k(o,n){let e=[],t=new Set,s=r=>{t.has(r)||(t.add(r),e.push(r))};s("Arguments are positional \u2014 pass them in the order listed in each skill's table");let i=Object.values(n).flatMap(r=>Object.values(r.inputSchema));i.some(r=>x(r,a.ZodNumber))&&s("Numeric args are auto-parsed \u2014 pass as plain numbers (e.g. `10`)"),i.some(r=>x(r,a.ZodArray))&&s('Array args must be valid JSON \u2014 wrap in single quotes on Unix shells (e.g. `\'["a","b"]\'`)'),i.some(r=>r instanceof a.ZodOptional||r instanceof a.ZodDefault)&&s("Optional args with defaults may be omitted");for(let r of Object.values(n))if(r.guidelines)for(let l of r.guidelines)s(l);return s(`Run \`${o}\` with no args to list all available skills`),e.map(r=>`- ${r}`).join(`
+`)}function x(o,n){let e=o;for(;e instanceof a.ZodOptional||e instanceof a.ZodDefault;)e=e.unwrap();return e instanceof n}function z(o){console.log(o.binName);let{binName:n,tools:e}=o;return Object.entries(e).map(([t,s])=>$(n,t,s)).join(`
+
+`)}function $(o,n,e){let t=Object.entries(e.inputSchema),s=t.map(([p,u])=>u instanceof a.ZodOptional||u instanceof a.ZodDefault?`[${p}]`:`<${p}>`).join(" "),i=[o,n,s].filter(Boolean).join(" "),r=t.map(([p,u])=>{let g=v(u),d=O(u);return`| \`${p}\` | ${g} | ${d} |`}).join(`
+`),l=e.examples??[],T="";if(l.length>0){let p=l.map(d=>[o,n,...d.args].join(" ")),u=Math.max(...p.map(d=>d.length));T=`
 
 \`\`\`sh
-${lines.join("\n")}
-\`\`\``;
-  }
-  const tableBlock = rows ? `
+${l.map((d,b)=>`${p[b].padEnd(u)}    # ${d.result}`).join(`
+`)}
+\`\`\``}let S=r?`
 
 | arg | type | description |
 |-----|------|-------------|
-${rows}` : "";
-  return `#### \`${key}\`
+${r}`:"";return`#### \`${n}\`
 
-${tool.description}.
+${e.description}.
 
 \`\`\`sh
-${usage}
-\`\`\`${tableBlock}${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";
-var tools = {
-  cnTool: toolDef({
-    name: "cn",
-    description: "Merges class names, filtering out falsy values",
-    inputSchema: {
-      classes: z3.array(z3.string()).describe("List of class names to merge")
-    },
-    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: 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)),
-    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: 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);
-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(/^-/, "");
-  }
-}
-export {
-  cn,
-  generateReadmeSkills,
-  generateSkillMarkdown,
-  tools
-};
+${i}
+\`\`\`${S}${T}`}function v(o){let n=o;for(;n instanceof a.ZodOptional||n instanceof a.ZodDefault;)n=n.unwrap();return n instanceof a.ZodEnum?n.options.map(e=>`\`${e}\``).join(" \\| "):n instanceof a.ZodNumber?"number":n instanceof a.ZodString?"string":n instanceof a.ZodBoolean?"boolean":n instanceof a.ZodArray?"JSON string (array)":"unknown"}function O(o){let n=o.description??"",e=o,t,s=!1;for(;e instanceof a.ZodOptional||e instanceof a.ZodDefault;){if(e instanceof a.ZodDefault){let i=e.def.defaultValue;t=typeof i=="function"?i():i}e instanceof a.ZodOptional&&(s=!0),e=e.unwrap()}return t!==void 0?`${n} (default: \`${String(t)}\`)`:s?`${n} (optional)`:n}import{z as f}from"zod";var m={cnTool:{name:"cn",description:"Merges class names, filtering out falsy values",inputSchema:{classes:f.array(f.string()).describe("List of class names to merge")},handler:async({classes:o})=>c(y(...o)),examples:[{args:[`'["btn","active","large"]'`],result:"btn active large"}]},caseConvertTool:{name:"case_convert",description:"Converts text to the specified case format",inputSchema:{input:f.string().describe("Text to convert"),to:f.enum(["upper","lower","capitalize","camel","snake","kebab"]).describe("Target case format")},handler:async({input:o,to:n})=>c(J(o,n)),examples:[{args:['"hello world"',"camel"],result:"helloWorld"},{args:['"helloWorld"',"snake"],result:"hello_world"},{args:['"hello world"',"kebab"],result:"hello-world"}]},truncateTool:{name:"truncate",description:"Truncates text to a maximum length and appends a suffix",inputSchema:{input:f.string().describe("Text to truncate"),maxLength:f.number().int().positive().describe("Maximum character length"),suffix:f.string().default("...").describe("Suffix to append when truncated")},handler:async({input:o,maxLength:n,suffix:e})=>{let t=o.length<=n?o:o.slice(0,n-e.length)+e;return c(t)},examples:[{args:['"hello world long text"',"10"],result:"hello w..."},{args:['"hello world"',"8",'"\u2026"'],result:"hello w\u2026"}]}},N=m.cnTool,C=m.caseConvertTool,E=m.truncateTool;function J(o,n){switch(n){case"upper":return o.toUpperCase();case"lower":return o.toLowerCase();case"capitalize":return o.charAt(0).toUpperCase()+o.slice(1).toLowerCase();case"camel":return o.replace(/[-_\s]+(.)/g,(e,t)=>t.toUpperCase()).replace(/^(.)/,e=>e.toLowerCase());case"snake":return o.replace(/([A-Z])/g,"_$1").replace(/[-\s]+/g,"_").toLowerCase().replace(/^_/,"");case"kebab":return o.replace(/([A-Z])/g,"-$1").replace(/[_\s]+/g,"-").toLowerCase().replace(/^-/,"")}}import{z as M}from"zod";function _(o){let n={};function e(t,s){if(t===null||typeof t!="object"||Array.isArray(t)){n[s]=t;return}for(let[i,r]of Object.entries(t)){let l=s?`${s}.${i}`:i;e(r,l)}}return e(o,""),n}var h={objectFlattenTool:{name:"object_flatten",description:"Flattens a nested JSON object of any depth into dot-notation key-value pairs. Accepts a JSON string and recursively flattens all levels. Arrays and primitives at any level are treated as leaf values.",inputSchema:{json:M.string().describe("JSON string of a nested object to flatten (unlimited depth)")},handler:async({json:o})=>{let n;try{let e=JSON.parse(o);if(typeof e!="object"||e===null||Array.isArray(e))return c(`Error: input must be a JSON object, got ${Array.isArray(e)?"array":typeof e}`);n=e}catch{return c("Error: invalid JSON string \u2014 unable to parse input")}try{let e=_(n);return c(JSON.stringify(e,null,2))}catch(e){return c(`Error: failed to flatten object \u2014 ${e.message}`)}},examples:[{args:[`'{"user":{"name":"Alice","address":{"city":"Seoul","zip":"12345"}},"active":true}'`],result:JSON.stringify({"user.name":"Alice","user.address.city":"Seoul","user.address.zip":"12345",active:!0},null,2)},{args:[`'{"a":{"b":{"c":{"d":{"e":"deep"}}}}}'`],result:JSON.stringify({"a.b.c.d.e":"deep"},null,2)}],guidelines:["Arrays and primitives at any level are always treated as leaf values \u2014 they are never traversed.","The result is always a flat JSON object with dot-notation keys.","There is no depth limit \u2014 objects of any nesting level are fully flattened."]}},L=h.objectFlattenTool;var V={...m,...h};export{y as cn,z as generateReadmeSkills,w as generateSkillMarkdown,V as tools};

package/dist/server.js

@@ -1,116 +1,2 @@
 #!/usr/bin/env node
-
-// ../common/kit/tool.ts
-function toolDef(def) {
-  return def;
-}
-function defineTool(tool) {
-  return tool;
-}
-function text(content) {
-  return { content: [{ type: "text", text: content }] };
-}
-
-// ../common/kit/server.ts
-import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
-import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
-function createMcpServer(config, tools2) {
-  const server2 = new McpServer(config);
-  for (const tool of tools2) {
-    server2.registerTool(
-      tool.name,
-      { description: tool.description, inputSchema: tool.inputSchema },
-      // eslint-disable-next-line @typescript-eslint/no-explicit-any
-      tool.handler
-    );
-  }
-  return server2;
-}
-async function startServer(server2) {
-  const transport = new StdioServerTransport();
-  await server2.connect(transport);
-}
-
-// ../common/kit/cli.ts
-import { z } from "zod";
-
-// ../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(" ");
-}
-
-// src/tools/text.ts
-var tools = {
-  cnTool: toolDef({
-    name: "cn",
-    description: "Merges class names, filtering out falsy values",
-    inputSchema: {
-      classes: z3.array(z3.string()).describe("List of class names to merge")
-    },
-    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: 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)),
-    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: 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);
-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/server.ts
-var server = createMcpServer({ name: "mono-rele2-utils", version: "1.0.0" }, [cnTool, caseConvertTool, truncateTool]);
-startServer(server).catch((err) => {
-  console.error("[utils] server error:", err);
-  process.exit(1);
-});
+function r(e){return{content:[{type:"text",text:e}]}}import{McpServer as S}from"@modelcontextprotocol/sdk/server/mcp.js";import{StdioServerTransport as x}from"@modelcontextprotocol/sdk/server/stdio.js";function m(e,o){let n=new S(e);for(let t of o)n.registerTool(t.name,{description:t.description,inputSchema:t.inputSchema},t.handler);return n}async function g(e){let o=new x;await e.connect(o)}import{z as N}from"zod";import{z as J}from"zod";import{z as s}from"zod";function y(...e){return e.filter(Boolean).join(" ")}var a={cnTool:{name:"cn",description:"Merges class names, filtering out falsy values",inputSchema:{classes:s.array(s.string()).describe("List of class names to merge")},handler:async({classes:e})=>r(y(...e)),examples:[{args:[`'["btn","active","large"]'`],result:"btn active large"}]},caseConvertTool:{name:"case_convert",description:"Converts text to the specified case format",inputSchema:{input:s.string().describe("Text to convert"),to:s.enum(["upper","lower","capitalize","camel","snake","kebab"]).describe("Target case format")},handler:async({input:e,to:o})=>r(Z(e,o)),examples:[{args:['"hello world"',"camel"],result:"helloWorld"},{args:['"helloWorld"',"snake"],result:"hello_world"},{args:['"hello world"',"kebab"],result:"hello-world"}]},truncateTool:{name:"truncate",description:"Truncates text to a maximum length and appends a suffix",inputSchema:{input:s.string().describe("Text to truncate"),maxLength:s.number().int().positive().describe("Maximum character length"),suffix:s.string().default("...").describe("Suffix to append when truncated")},handler:async({input:e,maxLength:o,suffix:n})=>{let t=e.length<=o?e:e.slice(0,o-n.length)+n;return r(t)},examples:[{args:['"hello world long text"',"10"],result:"hello w..."},{args:['"hello world"',"8",'"\u2026"'],result:"hello w\u2026"}]}},l=a.cnTool,c=a.caseConvertTool,p=a.truncateTool;function Z(e,o){switch(o){case"upper":return e.toUpperCase();case"lower":return e.toLowerCase();case"capitalize":return e.charAt(0).toUpperCase()+e.slice(1).toLowerCase();case"camel":return e.replace(/[-_\s]+(.)/g,(n,t)=>t.toUpperCase()).replace(/^(.)/,n=>n.toLowerCase());case"snake":return e.replace(/([A-Z])/g,"_$1").replace(/[-\s]+/g,"_").toLowerCase().replace(/^_/,"");case"kebab":return e.replace(/([A-Z])/g,"-$1").replace(/[_\s]+/g,"-").toLowerCase().replace(/^-/,"")}}import{z as A}from"zod";function j(e){let o={};function n(t,i){if(t===null||typeof t!="object"||Array.isArray(t)){o[i]=t;return}for(let[f,T]of Object.entries(t)){let h=i?`${i}.${f}`:f;n(T,h)}}return n(e,""),o}var u={objectFlattenTool:{name:"object_flatten",description:"Flattens a nested JSON object of any depth into dot-notation key-value pairs. Accepts a JSON string and recursively flattens all levels. Arrays and primitives at any level are treated as leaf values.",inputSchema:{json:A.string().describe("JSON string of a nested object to flatten (unlimited depth)")},handler:async({json:e})=>{let o;try{let n=JSON.parse(e);if(typeof n!="object"||n===null||Array.isArray(n))return r(`Error: input must be a JSON object, got ${Array.isArray(n)?"array":typeof n}`);o=n}catch{return r("Error: invalid JSON string \u2014 unable to parse input")}try{let n=j(o);return r(JSON.stringify(n,null,2))}catch(n){return r(`Error: failed to flatten object \u2014 ${n.message}`)}},examples:[{args:[`'{"user":{"name":"Alice","address":{"city":"Seoul","zip":"12345"}},"active":true}'`],result:JSON.stringify({"user.name":"Alice","user.address.city":"Seoul","user.address.zip":"12345",active:!0},null,2)},{args:[`'{"a":{"b":{"c":{"d":{"e":"deep"}}}}}'`],result:JSON.stringify({"a.b.c.d.e":"deep"},null,2)}],guidelines:["Arrays and primitives at any level are always treated as leaf values \u2014 they are never traversed.","The result is always a flat JSON object with dot-notation keys.","There is no depth limit \u2014 objects of any nesting level are fully flattened."]}},d=u.objectFlattenTool;var te={...a,...u};var v=m({name:"mono-rele2-utils",version:"1.0.0"},[l,c,p,d]);g(v).catch(e=>{console.error("[utils] server error:",e),process.exit(1)});

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

@@ -6,7 +6,7 @@ description: Use this skill to invoke text utility functions via the mono-rele2-
 # mono-rele2-utils-cli
 
 ```sh
-mono-rele2-utils-cli <skillName> [...args]
+mono-rele2-utils-cli <toolName> [...args]
 ```
 
 ## Skills
@@ -38,6 +38,14 @@ Truncates text to a maximum length and appends a suffix
 | `maxLength` | Maximum character length |
 | `suffix` | Suffix to append when truncated — default: `...` |
 
+### objectFlattenTool
+
+Flattens a nested JSON object of any depth into dot-notation key-value pairs. Accepts a JSON string and recursively flattens all levels. Arrays and primitives at any level are treated as leaf values.
+
+| arg | description |
+|-----|-------------|
+| `json` | JSON string of a nested object to flatten (unlimited depth) |
+
 ## Examples
 
 - `mono-rele2-utils-cli cnTool '["btn","active","large"]'` => `btn active large`
@@ -46,6 +54,15 @@ Truncates text to a maximum length and appends a suffix
 - `mono-rele2-utils-cli caseConvertTool "hello world" kebab` => `hello-world`
 - `mono-rele2-utils-cli truncateTool "hello world long text" 10` => `hello w...`
 - `mono-rele2-utils-cli truncateTool "hello world" 8 "…"` => `hello w…`
+- `mono-rele2-utils-cli objectFlattenTool '{"user":{"name":"Alice","address":{"city":"Seoul","zip":"12345"}},"active":true}'` => `{
+  "user.name": "Alice",
+  "user.address.city": "Seoul",
+  "user.address.zip": "12345",
+  "active": true
+}`
+- `mono-rele2-utils-cli objectFlattenTool '{"a":{"b":{"c":{"d":{"e":"deep"}}}}}'` => `{
+  "a.b.c.d.e": "deep"
+}`
 
 ## Guidelines
 
@@ -53,4 +70,7 @@ Truncates text to a maximum length and appends a suffix
 - 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
+- Arrays and primitives at any level are always treated as leaf values — they are never traversed.
+- The result is always a flat JSON object with dot-notation keys.
+- There is no depth limit — objects of any nesting level are fully flattened.
 - Run `mono-rele2-utils-cli` with no args to list all available skills

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@julong/mono-rele2-utils",
-  "version": "1.17.1",
+  "version": "1.19.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",
@@ -24,7 +24,7 @@
     "build": "tsup",
     "typecheck": "tsc --noEmit",
     "clean": "rimraf dist",
-    "readme": "node ../common/build/update-readme.mjs"
+    "readme": "bun ../common/build/update-readme.mjs"
   },
   "dependencies": {
     "@modelcontextprotocol/sdk": "^1.29.0",