@moewolf/moe-icons-cli 0.0.1

package/dist/generator/theme-resolve.js

@@ -0,0 +1,100 @@
+import { catalog, findCatalogStyleGroup } from "../catalog/catalog.js";
+import { assetRelativePath, resolveResourceVariant, } from "../core/resource-variant.js";
+import { toLibraryExportName, toProxyName } from "../core/icon-names.js";
+export function resolveThemes(config, sourceCatalog = catalog) {
+    const errors = [];
+    const themes = [];
+    for (const [theme, entry] of Object.entries(config.themes)) {
+        const group = findCatalogStyleGroup(entry.styleGroup, sourceCatalog);
+        if (!group) {
+            errors.push(`unknown style group "${entry.styleGroup}" for theme "${theme}"`);
+            continue;
+        }
+        if (group.type === "bitmap") {
+            try {
+                const variant = resolveResourceVariant(entry.styleGroup, {
+                    ...(entry.format !== undefined ? { format: entry.format } : {}),
+                    ...(entry.imageSize !== undefined ? { imageSize: entry.imageSize } : {}),
+                });
+                if (!group.formats.includes(variant.format)) {
+                    errors.push(`format ${variant.format} is unavailable for ${group.id}`);
+                }
+                if (!group.imageSizes.includes(variant.imageSize)) {
+                    errors.push(`imageSize ${String(variant.imageSize)} is unavailable for ${group.id}`);
+                }
+                themes.push({ theme, entry, kind: "bitmap", group, variant });
+            }
+            catch (error) {
+                errors.push(error instanceof Error ? error.message : String(error));
+            }
+        }
+        else {
+            themes.push({ theme, entry, kind: "svg", group });
+        }
+    }
+    if (errors.length > 0)
+        return { ok: false, errors };
+    return { ok: true, themes };
+}
+export function bitmapWrapperImportName(theme, iconId) {
+    return `${toProxyName(theme)}${toProxyName(iconId)}Bitmap`;
+}
+export function svgInternalImportName(theme, styleGroup, iconId) {
+    return `${toProxyName(theme)}${toProxyName(styleGroup)}${toProxyName(iconId)}`;
+}
+/** Relative import from icons/Foo.tsx → assets/... */
+export function relativeAssetImportFromIcons(variant, iconId) {
+    return `../${assetRelativePath(variant.resourceVariantId, iconId, variant.format)}`;
+}
+export function reactBitmapWrapperSource(iconId, wrapperName, variant, themeClassName) {
+    const assetImport = relativeAssetImportFromIcons(variant, iconId);
+    const defaultClass = themeClassName ? JSON.stringify(themeClassName) : "undefined";
+    return `import type { IconProps } from "../types";
+import { cn } from "../cn";
+import assetUrl from "${assetImport}";
+
+export function ${wrapperName}(props: IconProps) {
+  const { className, size, "aria-label": ariaLabel, strokeWidth: _strokeWidth, ...rest } = props;
+  const sizeClass = typeof size === "number" ? \`w-[\${size}px] h-[\${size}px]\` : undefined;
+  return (
+    <img
+      src={assetUrl}
+      alt={ariaLabel ?? ""}
+      aria-hidden={ariaLabel ? undefined : true}
+      draggable={false}
+      className={cn("moe-icon", ${defaultClass}, sizeClass, className)}
+      {...rest}
+    />
+  );
+}
+`;
+}
+export function vueBitmapWrapperSource(iconId, wrapperName, variant, themeClassName) {
+    const assetImport = relativeAssetImportFromIcons(variant, iconId);
+    const defaultClass = themeClassName ? JSON.stringify(themeClassName) : "undefined";
+    return `import { defineComponent, h } from "vue";
+import { cn } from "../cn";
+import assetUrl from "${assetImport}";
+
+export const ${wrapperName} = defineComponent({
+  name: "${wrapperName}",
+  setup(_props, { attrs }) {
+    return () => {
+      const className = typeof attrs.class === "string" ? attrs.class : undefined;
+      const size = typeof attrs.size === "number" ? attrs.size : undefined;
+      const ariaLabel = typeof attrs["aria-label"] === "string" ? attrs["aria-label"] : undefined;
+      const sizeClass = typeof size === "number" ? \`w-[\${size}px] h-[\${size}px]\` : undefined;
+      return h("img", {
+        ...attrs,
+        src: assetUrl,
+        alt: ariaLabel ?? "",
+        "aria-hidden": ariaLabel ? undefined : true,
+        draggable: false,
+        class: cn("moe-icon", ${defaultClass}, sizeClass, className),
+      });
+    };
+  },
+});
+`;
+}
+export { toLibraryExportName, toProxyName };

package/dist/mcp/server.d.ts

@@ -0,0 +1,58 @@
+/**
+ * Minimal MCP (Model Context Protocol) stdio server. Registers only v1 tools:
+ * list_icon_groups, get_account, install_icon_group. Protocol data goes only
+ * to stdout; logs go to stderr. Graceful shutdown on SIGINT/SIGTERM.
+ */
+interface McpRequest {
+    readonly jsonrpc: "2.0";
+    readonly id: number | string;
+    readonly method: string;
+    readonly params?: Record<string, unknown>;
+}
+interface McpResponse {
+    readonly jsonrpc: "2.0";
+    readonly id: number | string;
+    readonly result?: unknown;
+    readonly error?: {
+        code: number;
+        message: string;
+    };
+}
+export interface McpServices {
+    readonly listIconGroups: () => Promise<readonly {
+        id: string;
+        displayName: string;
+    }[]>;
+    readonly getAccount: () => Promise<{
+        accountId: string;
+        tier: string;
+    } | undefined>;
+    readonly installIconGroup: (args: {
+        groupId: string;
+        projectPath: string;
+    }) => Promise<{
+        ok: boolean;
+        message: string;
+    }>;
+}
+export interface McpDeps {
+    readonly services: McpServices;
+    readonly stdout: (text: string) => void;
+    readonly stderr: (text: string) => void;
+    readonly signal?: AbortSignal;
+}
+/**
+ * Create an MCP server bound to injected streams. Returns a dispatcher that
+ * handles one decoded JSON-RPC message.
+ */
+export declare function createMcpServer(deps: McpDeps): {
+    handle: (message: McpRequest) => Promise<McpResponse | undefined>;
+};
+/**
+ * Read JSON-RPC messages from an async iterable of lines and write responses to
+ * stdout. Used by the stdio transport.
+ */
+export declare function runMcpStdio(deps: McpDeps & {
+    lines: AsyncIterable<string>;
+}): Promise<void>;
+export {};

package/dist/mcp/server.js

@@ -0,0 +1,176 @@
+/**
+ * Minimal MCP (Model Context Protocol) stdio server. Registers only v1 tools:
+ * list_icon_groups, get_account, install_icon_group. Protocol data goes only
+ * to stdout; logs go to stderr. Graceful shutdown on SIGINT/SIGTERM.
+ */
+import { CLI_VERSION } from "../ui/banner.js";
+function validateArgs(method, params, required) {
+    if (!params) {
+        return undefined;
+    }
+    for (const key of required) {
+        if (typeof params[key] !== "string" || params[key].length === 0) {
+            return undefined;
+        }
+    }
+    const out = {};
+    for (const key of required) {
+        out[key] = String(params[key]);
+    }
+    return out;
+}
+/**
+ * Create an MCP server bound to injected streams. Returns a dispatcher that
+ * handles one decoded JSON-RPC message.
+ */
+export function createMcpServer(deps) {
+    const handle = async (message) => {
+        if (message.jsonrpc !== "2.0") {
+            return { jsonrpc: "2.0", id: message.id, error: { code: -32600, message: "invalid request" } };
+        }
+        switch (message.method) {
+            case "initialize":
+                return {
+                    jsonrpc: "2.0",
+                    id: message.id,
+                    result: {
+                        protocolVersion: "2024-11-05",
+                        capabilities: { tools: {} },
+                        serverInfo: { name: "moeicons", version: CLI_VERSION },
+                    },
+                };
+            case "tools/list":
+                return {
+                    jsonrpc: "2.0",
+                    id: message.id,
+                    result: {
+                        tools: [
+                            {
+                                name: "list_icon_groups",
+                                description: "List available icon groups",
+                                inputSchema: { type: "object", properties: {} },
+                            },
+                            {
+                                name: "get_account",
+                                description: "Get the current account/tier",
+                                inputSchema: { type: "object", properties: {} },
+                            },
+                            {
+                                name: "install_icon_group",
+                                description: "Install an icon group into a project",
+                                inputSchema: {
+                                    type: "object",
+                                    properties: {
+                                        groupId: { type: "string" },
+                                        projectPath: { type: "string" },
+                                    },
+                                    required: ["groupId", "projectPath"],
+                                },
+                            },
+                        ],
+                    },
+                };
+            case "tools/call": {
+                const toolName = message.params?.name;
+                const args = message.params?.arguments ?? {};
+                try {
+                    if (toolName === "list_icon_groups") {
+                        const groups = await deps.services.listIconGroups();
+                        return {
+                            jsonrpc: "2.0",
+                            id: message.id,
+                            result: { content: [{ type: "text", text: JSON.stringify(groups) }] },
+                        };
+                    }
+                    if (toolName === "get_account") {
+                        const account = await deps.services.getAccount();
+                        return {
+                            jsonrpc: "2.0",
+                            id: message.id,
+                            result: {
+                                content: [
+                                    { type: "text", text: account ? JSON.stringify(account) : "not logged in" },
+                                ],
+                            },
+                        };
+                    }
+                    if (toolName === "install_icon_group") {
+                        const validated = validateArgs(toolName, args, ["groupId", "projectPath"]);
+                        if (!validated) {
+                            return {
+                                jsonrpc: "2.0",
+                                id: message.id,
+                                error: { code: -32602, message: "groupId and projectPath are required strings" },
+                            };
+                        }
+                        const projectPath = validated["projectPath"];
+                        const groupId = validated["groupId"];
+                        if (!projectPath || !groupId) {
+                            return {
+                                jsonrpc: "2.0",
+                                id: message.id,
+                                error: { code: -32602, message: "groupId and projectPath are required strings" },
+                            };
+                        }
+                        if (projectPath.split(/[\\/]/).includes("..")) {
+                            return {
+                                jsonrpc: "2.0",
+                                id: message.id,
+                                error: { code: -32602, message: "projectPath must not contain path traversal" },
+                            };
+                        }
+                        const result = await deps.services.installIconGroup({
+                            groupId,
+                            projectPath,
+                        });
+                        return {
+                            jsonrpc: "2.0",
+                            id: message.id,
+                            result: { content: [{ type: "text", text: JSON.stringify(result) }] },
+                        };
+                    }
+                    return {
+                        jsonrpc: "2.0",
+                        id: message.id,
+                        error: { code: -32601, message: `unknown tool: ${String(toolName)}` },
+                    };
+                }
+                catch (error) {
+                    deps.stderr(`mcp tool error: ${String(error)}\n`);
+                    return {
+                        jsonrpc: "2.0",
+                        id: message.id,
+                        error: { code: -32000, message: String(error) },
+                    };
+                }
+            }
+            default:
+                return { jsonrpc: "2.0", id: message.id, error: { code: -32601, message: `method not found: ${message.method}` } };
+        }
+    };
+    return { handle };
+}
+/**
+ * Read JSON-RPC messages from an async iterable of lines and write responses to
+ * stdout. Used by the stdio transport.
+ */
+export async function runMcpStdio(deps) {
+    const server = createMcpServer(deps);
+    for await (const line of deps.lines) {
+        const trimmed = line.trim();
+        if (!trimmed)
+            continue;
+        let message;
+        try {
+            message = JSON.parse(trimmed);
+        }
+        catch {
+            deps.stdout(JSON.stringify({ jsonrpc: "2.0", id: null, error: { code: -32700, message: "parse error" } }) + "\n");
+            continue;
+        }
+        const response = await server.handle(message);
+        if (response) {
+            deps.stdout(JSON.stringify(response) + "\n");
+        }
+    }
+}

package/dist/project/config.d.ts

@@ -0,0 +1,74 @@
+import { type IconCatalog } from "../catalog/catalog.js";
+import type { Target } from "../commands/parser.js";
+export interface MoeiconsThemeConfig {
+    readonly styleGroup: string;
+    readonly styles?: readonly string[];
+    readonly format?: "svg" | "webp" | "png";
+    readonly imageSize?: 64 | 128 | 256 | 512;
+    readonly defaultSize?: number;
+    readonly strokeWidth?: number;
+    readonly className?: string;
+}
+/**
+ * Normalized config: schema version 2 with a REQUIRED `target`. Core code must
+ * never see an optional or missing target — v1 files are migrated by
+ * `readMoeiconsConfig` and invalid v2 files fail with a validation error
+ * instead of silently defaulting to React.
+ */
+export interface MoeiconsConfigFile {
+    readonly schemaVersion: 2;
+    readonly tier: "free" | "pro";
+    readonly target: Target;
+    readonly outputDir: string;
+    readonly defaultTheme: string;
+    readonly themes: Readonly<Record<string, MoeiconsThemeConfig>>;
+    readonly icons: readonly string[];
+    readonly missingIconPolicy?: "fallback" | "error";
+}
+/**
+ * Legacy v1 input shape. Reads normalize it into a `MoeiconsConfigFile` v2 by
+ * migrating `framework` to `target`. Core code never receives this type.
+ */
+export interface LegacyConfigInput {
+    readonly schemaVersion: 1;
+    readonly tier: "free" | "pro";
+    readonly framework: "react" | "vue";
+    readonly outputDir: string;
+    readonly defaultTheme: string;
+    readonly themes: Readonly<Record<string, MoeiconsThemeConfig>>;
+    readonly icons: readonly string[];
+    readonly missingIconPolicy?: "fallback" | "error";
+}
+export type ConfigLoadResult = {
+    readonly kind: "missing";
+} | {
+    readonly kind: "invalid";
+    readonly message: string;
+} | {
+    readonly kind: "unsupported";
+    readonly version: number;
+} | {
+    readonly kind: "ok";
+    readonly config: MoeiconsConfigFile;
+    readonly warnings: readonly string[];
+};
+export declare const SUPPORTED_FILENAMES: readonly ["moeicons.config.jsonc", "moeicons.config.json", "moeicons.config.ts", "moeicons.config.js"];
+export declare function findConfigFile(root: string): string | undefined;
+export declare function readMoeiconsConfig(root: string, sourceCatalog?: IconCatalog): ConfigLoadResult;
+export declare function mergeMoeiconsConfig(current: MoeiconsConfigFile | LegacyConfigInput, patch: Partial<Omit<MoeiconsConfigFile, "schemaVersion">>): MoeiconsConfigFile;
+export declare function createMoeiconsConfig(options: {
+    target?: Target;
+    /** Legacy v1 alias; still emits a v2 `target`. */
+    framework?: "react" | "vue";
+    tier?: "free" | "pro";
+    outputDir?: string;
+    icons?: readonly string[];
+    themes?: Readonly<Record<string, MoeiconsThemeConfig>>;
+}): MoeiconsConfigFile;
+/** Render the editable, grouped JSONC skeleton used by `init`. */
+export declare function renderMoeiconsConfigJsonc(options: {
+    target?: Target;
+    /** Legacy v1 alias; still emits a v2 `target`. */
+    framework?: "react" | "vue";
+    tier?: "free" | "pro";
+}): string;