@julong/mono-rele2-core 1.7.0 → 1.9.0

package/dist/index.d.ts

@@ -1,6 +1,6 @@
-import * as _modelcontextprotocol_sdk_server_mcp_js from '@modelcontextprotocol/sdk/server/mcp.js';
 import { CallToolResult } from '@modelcontextprotocol/sdk/types.js';
 import { z } from 'zod';
+import { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js';
 
 type ToolResult = CallToolResult;
 type ToolExample = {
@@ -16,16 +16,14 @@ type AnyToolDef = {
     guidelines?: string[];
 };
 
+declare function startServer(server: McpServer): Promise<void>;
+
 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: {
     echoTool: {
@@ -77,6 +75,4 @@ declare const tools: {
     };
 };
 
-declare function createCoreServer(): _modelcontextprotocol_sdk_server_mcp_js.McpServer;
-
-export { createCoreServer, generateReadmeSkills, generateSkillMarkdown, tools };
+export { generateSkillMarkdown, startServer, tools };

package/dist/index.js

@@ -24,9 +24,61 @@ function createMcpServer(config, tools2) {
   }
   return server;
 }
+async function startServer(server) {
+  const transport = new StdioServerTransport();
+  await server.connect(transport);
+}
 
 // ../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;
+  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";
@@ -135,80 +187,8 @@ function containsType(schema, ctor) {
   }
   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")}
-\`\`\``;
-  }
-  const tableBlock = rows ? `
-
-| arg | type | description |
-|-----|------|-------------|
-${rows}` : "";
-  return `#### \`${key}\`
-
-${tool.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/system.ts
+// src/tools/index.ts
 import { z as z3 } from "zod";
 import { randomUUID } from "crypto";
 var tools = {
@@ -263,15 +243,22 @@ var envTool = defineTool(tools.envTool);
 var uuidTool = defineTool(tools.uuidTool);
 
 // src/index.ts
-function createCoreServer() {
-  return createMcpServer(
-    { name: "mono-rele2-core", version: "1.0.0" },
-    [echoTool, timestampTool, envTool, uuidTool]
-  );
+if (process.argv.includes("--cli")) {
+  runCli(tools).catch(handleCliError);
+} else {
+  let createCoreServer = function() {
+    return createMcpServer({ name: "mono-rele2-core", version: "1.0.0" }, [echoTool, timestampTool, envTool, uuidTool]);
+  };
+  createCoreServer2 = createCoreServer;
+  const server = createCoreServer();
+  startServer(server).catch((err) => {
+    console.error("[core] server error:", err);
+    process.exit(1);
+  });
 }
+var createCoreServer2;
 export {
-  createCoreServer,
-  generateReadmeSkills,
   generateSkillMarkdown,
+  startServer,
   tools
 };

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

@@ -1,12 +1,12 @@
 ---
-name: mono-rele2-core-cli
+name: mono-rele2-core
 description: Use this skill to invoke core system utility functions via the mono-rele2-core CLI. Handles message echo, UTC timestamp generation, and environment variable lookup.
 ---
 
-# mono-rele2-core-cli
+# mono-rele2-core
 
 ```sh
-mono-rele2-core-cli <skillName> [...args]
+mono-rele2-core <skillName> [...args]
 ```
 
 ## Skills
@@ -45,16 +45,16 @@ Generates a random UUID v4
 
 ## Examples
 
-- `mono-rele2-core-cli echoTool "hello world"` => `hello world`
-- `mono-rele2-core-cli timestampTool` => `2026-05-02T00:00:00.000Z`
-- `mono-rele2-core-cli timestampTool unix` => `1746144000000`
-- `mono-rele2-core-cli envTool HOME` => `/Users/julong`
-- `mono-rele2-core-cli envTool NODE_ENV` => `development`
-- `mono-rele2-core-cli uuidTool` => `550e8400-e29b-41d4-a716-446655440000`
+- `mono-rele2-core echoTool "hello world"` => `hello world`
+- `mono-rele2-core timestampTool` => `2026-05-02T00:00:00.000Z`
+- `mono-rele2-core timestampTool unix` => `1746144000000`
+- `mono-rele2-core envTool HOME` => `/Users/julong`
+- `mono-rele2-core envTool NODE_ENV` => `development`
+- `mono-rele2-core uuidTool` => `550e8400-e29b-41d4-a716-446655440000`
 
 ## Guidelines
 
 - Arguments are positional — pass them in the order listed in each skill's table
 - Optional args with defaults may be omitted
 - `envTool` returns an empty string when the variable is not set
-- Run `mono-rele2-core-cli` with no args to list all available skills
+- Run `mono-rele2-core` with no args to list all available skills

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@julong/mono-rele2-core",
-  "version": "1.7.0",
+  "version": "1.9.0",
   "description": "Use this skill to invoke core system utility functions via the mono-rele2-core CLI. Handles message echo, UTC timestamp generation, and environment variable lookup.",
   "license": "ISC",
   "type": "module",
@@ -11,8 +11,7 @@
     }
   },
   "bin": {
-    "mono-rele2-core": "./dist/server.js",
-    "mono-rele2-core-cli": "./dist/cli.js"
+    "mono-rele2-core": "./dist/index.js"
   },
   "files": [
     "dist"

package/dist/cli.js

@@ -1,127 +0,0 @@
-#!/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";
-
-// ../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 [, , cliName, 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);
-}
-
-// ../common/kit/skill.ts
-import { z as z2 } from "zod";
-
-// src/tools/system.ts
-import { z as z3 } from "zod";
-import { randomUUID } from "crypto";
-var tools = {
-  echoTool: toolDef({
-    name: "echo",
-    description: "Returns the message as-is",
-    inputSchema: {
-      message: z3.string().describe("Message to echo")
-    },
-    handler: async ({ message }) => text(message),
-    examples: [{ args: [`"hello world"`], result: "hello world" }]
-  }),
-  timestampTool: toolDef({
-    name: "timestamp",
-    description: "Returns the current UTC timestamp",
-    inputSchema: {
-      format: z3.enum(["iso", "unix"]).default("iso").describe("Timestamp format")
-    },
-    handler: async ({ format }) => {
-      const value = format === "unix" ? String(Date.now()) : (/* @__PURE__ */ new Date()).toISOString();
-      return text(value);
-    },
-    examples: [
-      { args: [], result: "2026-05-02T00:00:00.000Z" },
-      { args: ["unix"], result: "1746144000000" }
-    ]
-  }),
-  envTool: toolDef({
-    name: "env",
-    description: "Returns the value of an environment variable",
-    inputSchema: {
-      key: z3.string().describe("Environment variable name")
-    },
-    handler: async ({ key }) => text(process.env[key] ?? ""),
-    examples: [
-      { args: ["HOME"], result: "/Users/julong" },
-      { args: ["NODE_ENV"], result: "development" }
-    ],
-    guidelines: ["`envTool` returns an empty string when the variable is not set"]
-  }),
-  uuidTool: toolDef({
-    name: "uuid",
-    description: "Generates a random UUID v4",
-    inputSchema: {},
-    handler: async () => text(randomUUID()),
-    examples: [{ args: [], result: "550e8400-e29b-41d4-a716-446655440000" }]
-  })
-};
-var echoTool = defineTool(tools.echoTool);
-var timestampTool = defineTool(tools.timestampTool);
-var envTool = defineTool(tools.envTool);
-var uuidTool = defineTool(tools.uuidTool);
-
-// src/cli.ts
-runCli(tools).catch(handleCliError);

package/dist/server.js

@@ -1,107 +0,0 @@
-#!/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/system.ts
-import { z as z3 } from "zod";
-import { randomUUID } from "crypto";
-var tools = {
-  echoTool: toolDef({
-    name: "echo",
-    description: "Returns the message as-is",
-    inputSchema: {
-      message: z3.string().describe("Message to echo")
-    },
-    handler: async ({ message }) => text(message),
-    examples: [{ args: [`"hello world"`], result: "hello world" }]
-  }),
-  timestampTool: toolDef({
-    name: "timestamp",
-    description: "Returns the current UTC timestamp",
-    inputSchema: {
-      format: z3.enum(["iso", "unix"]).default("iso").describe("Timestamp format")
-    },
-    handler: async ({ format }) => {
-      const value = format === "unix" ? String(Date.now()) : (/* @__PURE__ */ new Date()).toISOString();
-      return text(value);
-    },
-    examples: [
-      { args: [], result: "2026-05-02T00:00:00.000Z" },
-      { args: ["unix"], result: "1746144000000" }
-    ]
-  }),
-  envTool: toolDef({
-    name: "env",
-    description: "Returns the value of an environment variable",
-    inputSchema: {
-      key: z3.string().describe("Environment variable name")
-    },
-    handler: async ({ key }) => text(process.env[key] ?? ""),
-    examples: [
-      { args: ["HOME"], result: "/Users/julong" },
-      { args: ["NODE_ENV"], result: "development" }
-    ],
-    guidelines: ["`envTool` returns an empty string when the variable is not set"]
-  }),
-  uuidTool: toolDef({
-    name: "uuid",
-    description: "Generates a random UUID v4",
-    inputSchema: {},
-    handler: async () => text(randomUUID()),
-    examples: [{ args: [], result: "550e8400-e29b-41d4-a716-446655440000" }]
-  })
-};
-var echoTool = defineTool(tools.echoTool);
-var timestampTool = defineTool(tools.timestampTool);
-var envTool = defineTool(tools.envTool);
-var uuidTool = defineTool(tools.uuidTool);
-
-// src/index.ts
-function createCoreServer() {
-  return createMcpServer(
-    { name: "mono-rele2-core", version: "1.0.0" },
-    [echoTool, timestampTool, envTool, uuidTool]
-  );
-}
-
-// src/server.ts
-var server = createCoreServer();
-startServer(server).catch((err) => {
-  console.error("[core] server error:", err);
-  process.exit(1);
-});