@mongoui/skills 0.1.4

package/dist/cli.js

@@ -0,0 +1,46 @@
+#!/usr/bin/env node
+import { parseInstallOptions, runInstall, runUninstall } from "./commands/install.js";
+import { supportedToolsText } from "./tools/index.js";
+async function main() {
+    const args = process.argv.slice(2);
+    const [command, productName, ...restArgs] = args;
+    if (!isSupportedCommand(command)) {
+        printUsage(`Unsupported command: ${command ?? "(missing)"}`);
+        process.exitCode = 1;
+        return;
+    }
+    if (!productName) {
+        printUsage("Missing product name.");
+        process.exitCode = 1;
+        return;
+    }
+    try {
+        const options = parseInstallOptions(restArgs);
+        if (!options.tool) {
+            printUsage(`Missing required option: "--tool <${supportedToolsText()}>".`);
+            process.exitCode = 1;
+            return;
+        }
+        if (command === "install") {
+            await runInstall(productName, options);
+            return;
+        }
+        await runUninstall(productName, options);
+    }
+    catch (error) {
+        const message = error instanceof Error ? error.message : "Failed to parse command options.";
+        printUsage(message);
+        process.exitCode = 1;
+    }
+}
+function isSupportedCommand(command) {
+    return command === "install" || command === "uninstall";
+}
+function printUsage(errorMessage) {
+    if (errorMessage) {
+        console.error(`Error: ${errorMessage}`);
+    }
+    console.log("Usage:");
+    console.log(`  msg-skills <install|uninstall> <product-name> --tool <${supportedToolsText()}> [--target-dir <path>]`);
+}
+void main();

package/dist/commands/install.js

@@ -0,0 +1,90 @@
+import fs from "node:fs/promises";
+import path from "node:path";
+import { fileURLToPath } from "node:url";
+import { getProduct, listProducts } from "../products/index.js";
+import { parseToolName, renderInstalledContent, resolveInstallTarget, supportedToolsText, } from "../tools/index.js";
+export function parseInstallOptions(args) {
+    const options = {};
+    for (let index = 0; index < args.length; index += 1) {
+        const current = args[index];
+        if (current === "--tool") {
+            const nextValue = args[index + 1];
+            const parsedTool = parseToolName(nextValue);
+            if (parsedTool) {
+                options.tool = parsedTool;
+                index += 1;
+                continue;
+            }
+            throw new Error(`Invalid value for "--tool". Expected ${supportedToolsText()}.`);
+        }
+        if (current === "--target-dir") {
+            const nextValue = args[index + 1];
+            if (!nextValue) {
+                throw new Error('Missing value for "--target-dir".');
+            }
+            options.targetDir = nextValue;
+            index += 1;
+            continue;
+        }
+        throw new Error(`Unknown option: ${current}`);
+    }
+    return options;
+}
+export async function runInstall(productName, options) {
+    const packageRoot = path.resolve(path.dirname(fileURLToPath(import.meta.url)), "..", "..");
+    const product = requireProduct(productName);
+    if (!options.tool) {
+        throw new Error(`Missing required option: "--tool <${supportedToolsText()}>".`);
+    }
+    const installTarget = resolveInstallTarget(options.tool, options.targetDir);
+    const sourceSkillFile = path.join(packageRoot, product.skillFile);
+    const targetSkillFile = resolveTargetSkillFile(product.name, installTarget);
+    await fs.access(sourceSkillFile);
+    const sourceSkillContent = await fs.readFile(sourceSkillFile, "utf8");
+    const targetSkillContent = renderInstalledContent(installTarget.tool, product.name, product.displayName, sourceSkillContent);
+    await fs.mkdir(installTarget.targetDir, { recursive: true });
+    await fs.writeFile(targetSkillFile, targetSkillContent, "utf8");
+    console.log("Installed skill:");
+    console.log("- command: install");
+    console.log(`- product: ${product.name}`);
+    console.log(`- display name: ${product.displayName}`);
+    console.log(`- tool: ${installTarget.tool}`);
+    console.log(`- source skill file: ${sourceSkillFile}`);
+    console.log(`- target dir: ${installTarget.targetDir}`);
+    console.log(`- target source: ${installTarget.source}`);
+    console.log(`- target skill file: ${targetSkillFile}`);
+    console.log(`- target format: ${installTarget.fileExtension}`);
+    console.log("- status: installed");
+}
+export async function runUninstall(productName, options) {
+    const product = requireProduct(productName);
+    if (!options.tool) {
+        throw new Error(`Missing required option: "--tool <${supportedToolsText()}>".`);
+    }
+    const installTarget = resolveInstallTarget(options.tool, options.targetDir);
+    const targetSkillFile = resolveTargetSkillFile(product.name, installTarget);
+    await fs.rm(targetSkillFile, { force: true });
+    console.log("Uninstalled skill:");
+    console.log("- command: uninstall");
+    console.log(`- product: ${product.name}`);
+    console.log(`- display name: ${product.displayName}`);
+    console.log(`- tool: ${installTarget.tool}`);
+    console.log(`- target dir: ${installTarget.targetDir}`);
+    console.log(`- target source: ${installTarget.source}`);
+    console.log(`- target skill file: ${targetSkillFile}`);
+    console.log(`- target format: ${installTarget.fileExtension}`);
+    console.log("- status: removed");
+}
+function requireProduct(productName) {
+    const product = getProduct(productName);
+    if (!product) {
+        const supportedProducts = listProducts()
+            .map((item) => item.name)
+            .join(", ");
+        throw new Error(`Unknown product: ${productName}. Supported products: ${supportedProducts}`);
+    }
+    return product;
+}
+function resolveTargetSkillFile(productName, installTarget) {
+    return path.join(installTarget.targetDir, installTarget.fileName ?? `${productName}.${installTarget.fileExtension}`);
+}

package/dist/examples/glink-hotel-auth.js

@@ -0,0 +1,55 @@
+export function createGlinkAuthHeaders(accessToken) {
+    if (!accessToken.trim()) {
+        throw new Error("Missing Glink access token.");
+    }
+    return {
+        Authorization: `Bearer ${accessToken}`,
+        "Content-Type": "application/json",
+    };
+}
+export async function glinkPost(config, endpoint, payload) {
+    const response = await fetch(`${config.baseUrl}${endpoint}`, {
+        method: "POST",
+        headers: createGlinkAuthHeaders(config.accessToken),
+        body: JSON.stringify(payload),
+    });
+    if (!response.ok) {
+        const errorText = await response.text();
+        throw new Error(`Glink request failed: ${response.status} ${errorText}`);
+    }
+    return response.json();
+}
+export async function getHotelList(config, payload) {
+    return glinkPost(config, "/v1/hotel/list", payload);
+}
+async function main() {
+    const accessToken = process.env.GLINK_ACCESS_TOKEN ?? "";
+    const clientConfig = {
+        baseUrl: "https://api.glink.example.com",
+        accessToken,
+    };
+    const payload = {
+        cityCode: "BJS",
+        checkIn: "2026-05-01",
+        checkOut: "2026-05-03",
+        rooms: 1,
+        adults: 2,
+        starRating: [4, 5],
+        sortBy: "price",
+        page: 1,
+        pageSize: 20,
+    };
+    try {
+        const result = await getHotelList(clientConfig, payload);
+        console.log("Glink hotel list result:");
+        console.log(JSON.stringify(result, null, 2));
+    }
+    catch (error) {
+        const message = error instanceof Error ? error.message : "Unknown error while calling Glink API.";
+        console.error(message);
+        process.exitCode = 1;
+    }
+}
+if (import.meta.url === `file://${process.argv[1]}`) {
+    void main();
+}

package/dist/products/index.js

@@ -0,0 +1,23 @@
+const PRODUCTS = {
+    "glink-hotel-api": {
+        name: "glink-hotel-api",
+        displayName: "Glink Hotel API",
+        skillFile: "skills/glink-hotel-api/SKILL.md",
+    },
+    "flink-flight-api": {
+        name: "flink-flight-api",
+        displayName: "Flink Flight API",
+        skillFile: "skills/flink-flight-api/SKILL.md",
+    },
+    "tmc-whitelabel": {
+        name: "tmc-whitelabel",
+        displayName: "TMC Whitelabel",
+        skillFile: "skills/tmc-whitelabel/SKILL.md",
+    },
+};
+export function getProduct(productName) {
+    return PRODUCTS[productName];
+}
+export function listProducts() {
+    return Object.values(PRODUCTS);
+}

package/dist/tools/index.js

@@ -0,0 +1,162 @@
+import os from "node:os";
+import path from "node:path";
+const TOOL_ALIASES = {
+    codex: "codex",
+    cursor: "cursor",
+    kiro: "kiro",
+    claude: "claude-code",
+    "claude-code": "claude-code",
+    gemini: "gemini-cli",
+    "gemini-cli": "gemini-cli",
+};
+const TOOL_NAMES = ["codex", "cursor", "kiro", "claude-code", "gemini-cli"];
+export function supportedToolsText() {
+    return [...new Set(Object.keys(TOOL_ALIASES))].join("|");
+}
+export function parseToolName(toolName) {
+    if (!toolName) {
+        return undefined;
+    }
+    return TOOL_ALIASES[toolName];
+}
+export function resolveInstallTarget(tool, targetDir) {
+    if (targetDir) {
+        return {
+            tool,
+            targetDir: path.resolve(targetDir),
+            source: "custom",
+            fileExtension: tool === "cursor" ? "mdc" : "md",
+            fileName: getToolFileName(tool),
+        };
+    }
+    switch (tool) {
+        case "codex": {
+            const codexHome = process.env.CODEX_HOME ?? path.join(os.homedir(), ".codex");
+            return {
+                tool,
+                targetDir: path.join(codexHome, "skills"),
+                source: "default",
+                fileExtension: "md",
+                fileName: undefined,
+            };
+        }
+        case "cursor": {
+            const cursorRulesDir = process.env.CURSOR_RULES_DIR ?? path.join(process.cwd(), ".cursor", "rules");
+            return {
+                tool,
+                targetDir: cursorRulesDir,
+                source: "default",
+                fileExtension: "mdc",
+                fileName: undefined,
+            };
+        }
+        case "kiro": {
+            const kiroHome = process.env.KIRO_HOME ?? path.join(os.homedir(), ".kiro");
+            return {
+                tool,
+                targetDir: path.join(kiroHome, "skills"),
+                source: "default",
+                fileExtension: "md",
+                fileName: undefined,
+            };
+        }
+        case "claude-code": {
+            const claudeHome = process.env.CLAUDE_HOME ?? path.join(os.homedir(), ".claude");
+            return {
+                tool,
+                targetDir: path.join(claudeHome, "agents"),
+                source: "default",
+                fileExtension: "md",
+                fileName: undefined,
+            };
+        }
+        case "gemini-cli": {
+            const geminiDir = process.env.GEMINI_HOME ?? process.cwd();
+            return {
+                tool,
+                targetDir: path.resolve(geminiDir),
+                source: "default",
+                fileExtension: "md",
+                fileName: "GEMINI.md",
+            };
+        }
+    }
+}
+export function renderInstalledContent(tool, productName, displayName, sourceContent) {
+    switch (tool) {
+        case "cursor": {
+            const skillBody = stripLeadingFrontmatter(sourceContent).trim();
+            return [
+                "---",
+                `description: Imported rule for ${displayName}`,
+                "alwaysApply: false",
+                "---",
+                "",
+                `# ${displayName}`,
+                "",
+                `Imported from msg-skills as the \`${productName}\` rule.`,
+                "",
+                skillBody,
+                "",
+            ].join("\n");
+        }
+        case "claude-code": {
+            const description = extractDescription(sourceContent) ?? `Use for ${displayName} tasks.`;
+            const skillBody = stripLeadingFrontmatter(sourceContent).trim();
+            return [
+                "---",
+                `name: ${productName}`,
+                `description: ${description}`,
+                "---",
+                "",
+                skillBody,
+                "",
+            ].join("\n");
+        }
+        case "gemini-cli": {
+            const skillBody = stripLeadingFrontmatter(sourceContent).trim();
+            return [
+                `# ${displayName}`,
+                "",
+                `Imported from msg-skills for \`${productName}\`.`,
+                "",
+                skillBody,
+                "",
+            ].join("\n");
+        }
+        default:
+            return sourceContent;
+    }
+}
+function stripLeadingFrontmatter(sourceContent) {
+    if (!sourceContent.startsWith("---\n")) {
+        return sourceContent;
+    }
+    const frontmatterEnd = sourceContent.indexOf("\n---\n", 4);
+    if (frontmatterEnd === -1) {
+        return sourceContent;
+    }
+    return sourceContent.slice(frontmatterEnd + 5);
+}
+function extractDescription(sourceContent) {
+    if (!sourceContent.startsWith("---\n")) {
+        return undefined;
+    }
+    const frontmatterEnd = sourceContent.indexOf("\n---\n", 4);
+    if (frontmatterEnd === -1) {
+        return undefined;
+    }
+    const frontmatter = sourceContent.slice(4, frontmatterEnd);
+    for (const line of frontmatter.split("\n")) {
+        if (line.startsWith("description:")) {
+            return line.slice("description:".length).trim();
+        }
+    }
+    return undefined;
+}
+function getToolFileName(tool) {
+    if (tool === "gemini-cli") {
+        return "GEMINI.md";
+    }
+    return undefined;
+}

package/package.json

@@ -0,0 +1,26 @@
+{
+  "name": "@mongoui/skills",
+  "version": "0.1.4",
+  "description": "CLI for installing product skills into AI tools",
+  "license": "MIT",
+  "publishConfig": {
+    "access": "public"
+  },
+  "type": "module",
+  "bin": {
+    "msg-skills": "dist/cli.js"
+  },
+  "files": [
+    "dist",
+    "skills"
+  ],
+  "scripts": {
+    "build": "tsc -p tsconfig.json",
+    "dev": "tsx src/cli.ts"
+  },
+  "devDependencies": {
+    "@types/node": "^24.6.0",
+    "tsx": "^4.20.6",
+    "typescript": "^5.9.3"
+  }
+}

package/skills/flink-flight-api/SKILL.md

@@ -0,0 +1,8 @@
+---
+name: flink-flight-api
+description: Placeholder skill for Flink Flight API.
+---
+
+# Flink Flight API
+
+内容待补充。

package/skills/glink-hotel-api/SKILL.md

@@ -0,0 +1,175 @@
+---
+name: glink-hotel-api
+description: Glink 酒店 API 接入规范。支持鉴权、酒店列表查询、参数封装、错误处理。触发词：Glink、酒店接口、酒店查询、鉴权函数、hotel list。
+---
+
+# Glink Hotel API
+
+## 目标
+
+当用户提到 Glink 酒店相关需求时，优先帮助用户完成以下任务：
+
+- 实现 Glink API 的鉴权逻辑
+- 封装酒店列表查询函数
+- 生成 Node.js / TypeScript 调用示例
+- 根据接口文档补全请求头、请求体、错误处理
+- 在业务项目中封装可复用的 service / sdk 方法
+
+默认优先输出 TypeScript 示例，其次是 JavaScript。
+
+## 核心规则
+
+- 所有请求默认使用 HTTPS
+- 所有受保护接口必须携带 `Authorization: Bearer {access_token}`
+- 请求头必须包含 `Content-Type: application/json`
+- 日期字段使用 `YYYY-MM-DD`
+- 示例代码优先使用 `fetch`
+- 如果用户项目明显使用 `axios`，则跟随项目风格
+- 如果用户要求“实现函数”，默认补全类型定义、请求函数、错误处理
+- 如果用户没有说明运行环境，默认按 Node.js 18+ 处理
+- 如果用户没有说明框架，默认给出独立可复用函数，不强绑定 NestJS/Express
+
+## 鉴权要求
+
+当用户提到“鉴权”“token”“Bearer”“access_token”时：
+
+- 明确告诉用户需要在请求头中传递 Bearer Token
+- 不要把 token 写死在代码里
+- 优先从函数参数、环境变量或配置对象中读取 token
+- 生成代码时，默认将鉴权逻辑封装为独立函数或统一请求客户端
+
+推荐模式：
+
+1. 先定义配置项
+2. 再封装请求方法
+3. 再封装业务接口方法
+
+## 常见接口示例
+
+### 查询酒店列表
+
+```http
+POST /v1/hotel/list
+Authorization: Bearer {access_token}
+Content-Type: application/json
+
+{
+  "cityCode": "BJS",
+  "checkIn": "2026-05-01",
+  "checkOut": "2026-05-03",
+  "rooms": 1,
+  "adults": 2,
+  "starRating": [4, 5],
+  "sortBy": "price",
+  "page": 1,
+  "pageSize": 20
+}
+```
+
+## TypeScript 示例
+
+```ts
+type HotelListRequest = {
+  cityCode: string;
+  checkIn: string;
+  checkOut: string;
+  rooms: number;
+  adults: number;
+  starRating?: number[];
+  sortBy?: string;
+  page?: number;
+  pageSize?: number;
+};
+
+type GlinkClientOptions = {
+  baseUrl: string;
+  accessToken: string;
+};
+
+async function glinkRequest<T>(
+  path: string,
+  options: GlinkClientOptions,
+  body: unknown,
+): Promise<T> {
+  const response = await fetch(`${options.baseUrl}${path}`, {
+    method: "POST",
+    headers: {
+      Authorization: `Bearer ${options.accessToken}`,
+      "Content-Type": "application/json",
+    },
+    body: JSON.stringify(body),
+  });
+
+  if (!response.ok) {
+    const errorText = await response.text();
+    throw new Error(`Glink request failed: ${response.status} ${errorText}`);
+  }
+
+  return response.json() as Promise<T>;
+}
+
+export async function getHotelList<T>(
+  options: GlinkClientOptions,
+  payload: HotelListRequest,
+): Promise<T> {
+  return glinkRequest<T>("/v1/hotel/list", options, payload);
+}
+```
+
+## 当用户这样提问时
+
+### 用户说
+
+`帮我实现 Glink 鉴权函数`
+
+应该优先输出：
+
+- 一个可复用的鉴权请求封装
+- 如何传入 `access_token`
+- 如何设置 `Authorization: Bearer ...`
+- 一个最小可运行示例
+
+### 用户说
+
+`帮我调用 Glink 酒店列表接口`
+
+应该优先输出：
+
+- 请求函数
+- 请求参数类型
+- 调用示例
+- 错误处理
+- 必要请求头
+
+### 用户说
+
+`帮我封装成 service`
+
+应该优先输出：
+
+- 一个类或模块化 service
+- 构造函数接收 `baseUrl` 和 `accessToken`
+- 业务方法如 `getHotelList`
+
+## 输出要求
+
+- 优先输出完整可运行代码，而不是只解释思路
+- 如果用户没有要求框架，优先输出纯 TypeScript 函数
+- 如果接口字段不完整，明确标注“以下字段基于当前 Skills 示例推断”
+- 如果缺少响应结构，不要编造复杂返回值类型，可先使用泛型或基础类型
+- 如果用户要求接入现有项目，尽量贴近项目已有代码风格
+
+## 常见注意事项
+
+- 不要把 `Authorization` 写成普通自定义字段
+- 不要漏掉 `Content-Type: application/json`
+- 不要把日期写成时间戳，除非用户明确要求
+- 不要默认把所有字段都设成可选
+- 不要把分页参数写死
+- 如果用户要生产代码，提醒 token 不应硬编码
+
+## 回答风格
+
+- 直接给代码
+- 再简要说明关键点
+- 优先面向接入开发，不做空泛概念解释

package/skills/tmc-whitelabel/SKILL.md

@@ -0,0 +1,8 @@
+---
+name: tmc-whitelabel
+description: Placeholder skill for TMC Whitelabel.
+---
+
+# TMC Whitelabel
+
+内容待补充。