@moewolf/moe-icons-cli 0.0.1

package/dist/project/project-lock.js

@@ -0,0 +1,81 @@
+import { closeSync, existsSync, openSync, readFileSync, unlinkSync, writeFileSync } from "node:fs";
+import { join } from "node:path";
+import { CliError } from "../errors/index.js";
+const defaultIo = {
+    exists: existsSync,
+    read: (path) => readFileSync(path, "utf8"),
+    createExclusive: (path, content) => { const fd = openSync(path, "wx", 0o600); try {
+        writeFileSync(fd, content);
+    }
+    finally {
+        closeSync(fd);
+    } },
+    remove: unlinkSync,
+    isProcessAlive: (pid) => { try {
+        process.kill(pid, 0);
+        return true;
+    }
+    catch {
+        return false;
+    } },
+    now: Date.now,
+    pid: process.pid,
+};
+export async function withProjectLock(projectRoot, operation, work, io = defaultIo) {
+    const path = join(projectRoot, ".moeicons.lock");
+    if (io.exists(path)) {
+        let stale = false;
+        try {
+            const value = JSON.parse(io.read(path));
+            stale = typeof value.pid === "number" && typeof value.createdAt === "number" && io.now() - value.createdAt > 30 * 60_000 && !io.isProcessAlive(value.pid);
+        }
+        catch {
+            stale = false;
+        }
+        if (!stale)
+            throw new CliError("VALIDATION_ERROR", "another moeicons install/update/reload operation is already running");
+        io.remove(path);
+    }
+    try {
+        io.createExclusive(path, JSON.stringify({ schemaVersion: 1, pid: io.pid, operation, createdAt: io.now() }));
+    }
+    catch {
+        throw new CliError("VALIDATION_ERROR", "another moeicons install/update/reload operation is already running");
+    }
+    try {
+        return await work();
+    }
+    finally {
+        if (io.exists(path))
+            io.remove(path);
+    }
+}
+export function withProjectLockSync(projectRoot, operation, work, io = defaultIo) {
+    const path = join(projectRoot, ".moeicons.lock");
+    if (io.exists(path)) {
+        let stale = false;
+        try {
+            const value = JSON.parse(io.read(path));
+            stale = typeof value.pid === "number" && typeof value.createdAt === "number" && io.now() - value.createdAt > 30 * 60_000 && !io.isProcessAlive(value.pid);
+        }
+        catch {
+            stale = false;
+        }
+        if (!stale)
+            throw new CliError("VALIDATION_ERROR", "another moeicons install/update/reload operation is already running");
+        io.remove(path);
+    }
+    try {
+        io.createExclusive(path, JSON.stringify({ schemaVersion: 1, pid: io.pid, operation, createdAt: io.now() }));
+    }
+    catch {
+        throw new CliError("VALIDATION_ERROR", "another moeicons install/update/reload operation is already running");
+    }
+    try {
+        return work();
+    }
+    finally {
+        if (io.exists(path))
+            io.remove(path);
+    }
+}

package/dist/project/tailwind.d.ts

@@ -0,0 +1,51 @@
+/**
+ * H3: only rewrite Tailwind v3 configs whose `content` is a static string-array
+ * literal. Other shapes get a precise manual hint. Tailwind v4 → typed error.
+ */
+export type TailwindDetectResult = {
+    readonly kind: "missing";
+} | {
+    readonly kind: "v3";
+    readonly configPath: string;
+    readonly source: string;
+} | {
+    readonly kind: "v4";
+    readonly configPath: string;
+} | {
+    readonly kind: "unknown";
+    readonly configPath: string;
+    readonly source: string;
+};
+export declare function findTailwindConfig(projectRoot: string): string | undefined;
+export declare function detectTailwind(projectRoot: string): TailwindDetectResult;
+export type ContentInjectResult = {
+    readonly ok: true;
+    readonly changed: boolean;
+    readonly nextSource: string;
+} | {
+    readonly ok: false;
+    readonly reason: "unsupported-shape";
+    readonly hint: string;
+};
+/** Idempotently append a glob to a static `content: [ ... ]` array. */
+export declare function injectContentGlob(source: string, glob: string): ContentInjectResult;
+export declare function moeiconsContentGlob(outputDir: string, target?: "react" | "vue" | "vanilla" | "assets"): string;
+/**
+ * Apply Tailwind content injection. Throws CliError(TAILWIND_VERSION_UNSUPPORTED)
+ * for v4 when integration is requested.
+ */
+export declare function planTailwindIntegration(projectRoot: string, outputDir: string, options: {
+    readonly noTailwind: boolean;
+    readonly target?: "react" | "vue" | "vanilla" | "assets";
+}): {
+    readonly files: readonly {
+        path: string;
+        content: string;
+    }[];
+    readonly notes: readonly string[];
+};
+export declare function ensureClassMergeDependencies(source: string): {
+    readonly nextSource: string;
+    readonly changed: boolean;
+    readonly notes: string[];
+};

package/dist/project/tailwind.js

@@ -0,0 +1,188 @@
+import { existsSync, readFileSync } from "node:fs";
+import { join } from "node:path";
+import { CliError } from "../errors/index.js";
+import { CLSX_VERSION_RANGE, TAILWIND_MERGE_VERSION_RANGE } from "../generator/cn.js";
+import { applyEdits, modify } from "jsonc-parser";
+const CONFIG_CANDIDATES = [
+    "tailwind.config.js",
+    "tailwind.config.cjs",
+    "tailwind.config.mjs",
+    "tailwind.config.ts",
+];
+export function findTailwindConfig(projectRoot) {
+    for (const name of CONFIG_CANDIDATES) {
+        const path = join(projectRoot, name);
+        if (existsSync(path))
+            return path;
+    }
+    return undefined;
+}
+function packageDeclaresTailwindV4(projectRoot) {
+    const pkgPath = join(projectRoot, "package.json");
+    if (!existsSync(pkgPath))
+        return false;
+    try {
+        const pkg = JSON.parse(readFileSync(pkgPath, "utf8"));
+        const range = pkg.dependencies?.tailwindcss ?? pkg.devDependencies?.tailwindcss;
+        if (!range)
+            return false;
+        return (range.startsWith("^4") ||
+            range.startsWith("~4") ||
+            range.startsWith(">=4") ||
+            /^4(\.|$)/.test(range));
+    }
+    catch {
+        return false;
+    }
+}
+export function detectTailwind(projectRoot) {
+    const configPath = findTailwindConfig(projectRoot);
+    if (packageDeclaresTailwindV4(projectRoot)) {
+        return { kind: "v4", configPath: configPath ?? join(projectRoot, "package.json") };
+    }
+    if (!configPath)
+        return { kind: "missing" };
+    const source = readFileSync(configPath, "utf8");
+    if (/\b@tailwindcss\/(vite|postcss)\b/.test(source)) {
+        return { kind: "v4", configPath };
+    }
+    if (/content\s*:/.test(source))
+        return { kind: "v3", configPath, source };
+    return { kind: "unknown", configPath, source };
+}
+const CONTENT_ARRAY_RE = /(content\s*:\s*)\[([\s\S]*?)\]/;
+/** Idempotently append a glob to a static `content: [ ... ]` array. */
+export function injectContentGlob(source, glob) {
+    if (source.includes(glob)) {
+        return { ok: true, changed: false, nextSource: source };
+    }
+    const match = CONTENT_ARRAY_RE.exec(source);
+    if (!match || match.index === undefined) {
+        return {
+            ok: false,
+            reason: "unsupported-shape",
+            hint: `Could not safely edit Tailwind content; add ${JSON.stringify(glob)} to content manually.`,
+        };
+    }
+    const full = match[0];
+    if (/require\(|import\(|\.\.\./.test(full)) {
+        return {
+            ok: false,
+            reason: "unsupported-shape",
+            hint: `Tailwind content is not a static string array; add ${JSON.stringify(glob)} manually.`,
+        };
+    }
+    const prefix = match[1] ?? "content: ";
+    const body = match[2] ?? "";
+    const trimmed = body.replace(/\s+$/, "");
+    const needsComma = trimmed.length > 0 && !trimmed.trimEnd().endsWith(",");
+    const insertion = `${needsComma ? "," : ""}\n    ${JSON.stringify(glob)}`;
+    const nextArray = `${prefix}[${trimmed}${insertion}\n  ]`;
+    return { ok: true, changed: true, nextSource: source.replace(full, nextArray) };
+}
+export function moeiconsContentGlob(outputDir, target) {
+    const normalized = outputDir.replace(/\\/g, "/").replace(/\/$/, "");
+    const extensions = target === undefined
+        ? "js,ts,jsx,tsx,vue"
+        : target === "react"
+            ? "js,ts,jsx,tsx"
+            : target === "vue"
+                ? "js,ts,vue"
+                : "js,ts,html,svg";
+    return `./${normalized}/**/*.{${extensions}}`;
+}
+/**
+ * Apply Tailwind content injection. Throws CliError(TAILWIND_VERSION_UNSUPPORTED)
+ * for v4 when integration is requested.
+ */
+export function planTailwindIntegration(projectRoot, outputDir, options) {
+    if (options.noTailwind) {
+        return { files: [], notes: ["skipped Tailwind config (--no-tailwind)"] };
+    }
+    if (options.target === "vanilla" || options.target === "assets") {
+        return { files: [], notes: [`skipped Tailwind integration for ${options.target} target`] };
+    }
+    const detected = detectTailwind(projectRoot);
+    if (detected.kind === "missing") {
+        return { files: [], notes: ["no Tailwind config found; skipped content injection"] };
+    }
+    if (detected.kind === "v4") {
+        throw new CliError("TAILWIND_VERSION_UNSUPPORTED", "Tailwind CSS v4 was detected; this CLI release only auto-integrates Tailwind v3. Pass --no-tailwind to skip Tailwind config changes.");
+    }
+    if (detected.kind === "unknown") {
+        return {
+            files: [],
+            notes: [
+                `Tailwind config ${detected.configPath} has no static content array; add ${JSON.stringify(moeiconsContentGlob(outputDir))} manually.`,
+            ],
+        };
+    }
+    const glob = moeiconsContentGlob(outputDir, options.target);
+    const injected = injectContentGlob(detected.source, glob);
+    if (!injected.ok) {
+        return { files: [], notes: [injected.hint] };
+    }
+    if (!injected.changed) {
+        return { files: [], notes: [`Tailwind content already includes ${glob}`] };
+    }
+    return {
+        files: [{ path: detected.configPath, content: injected.nextSource }],
+        notes: [`updated ${detected.configPath} content with ${glob}`],
+    };
+}
+export function ensureClassMergeDependencies(source) {
+    const notes = [];
+    let pkg;
+    try {
+        pkg = JSON.parse(source);
+    }
+    catch {
+        return {
+            nextSource: source,
+            changed: false,
+            notes: ["package.json is not valid JSON; skipped clsx/tailwind-merge"],
+        };
+    }
+    const deps = { ...(pkg.dependencies ?? {}) };
+    let changed = false;
+    if (!deps.clsx) {
+        deps.clsx = CLSX_VERSION_RANGE;
+        changed = true;
+        notes.push(`add dependencies.clsx ${CLSX_VERSION_RANGE}`);
+    }
+    if (!deps["tailwind-merge"]) {
+        deps["tailwind-merge"] = TAILWIND_MERGE_VERSION_RANGE;
+        changed = true;
+        notes.push(`add dependencies.tailwind-merge ${TAILWIND_MERGE_VERSION_RANGE}`);
+    }
+    if (!changed)
+        return { nextSource: source, changed: false, notes: ["clsx/tailwind-merge already declared"] };
+    const eol = source.includes("\r\n") ? "\r\n" : "\n";
+    const indent = source.match(/\n([ \t]+)"/)?.[1] ?? "  ";
+    const formattingOptions = {
+        insertSpaces: !indent.includes("\t"),
+        tabSize: indent.includes("\t") ? 1 : indent.length,
+        eol,
+    };
+    if (!pkg.dependencies) {
+        const closing = source.lastIndexOf("}");
+        const beforeClosing = source.slice(0, closing);
+        const whitespace = beforeClosing.match(/\s*$/)?.[0] ?? "";
+        const body = beforeClosing.slice(0, beforeClosing.length - whitespace.length);
+        const comma = Object.keys(pkg).length > 0 ? "," : "";
+        const block = `${comma}${eol}${indent}"dependencies": {${eol}${indent}${indent}"clsx": ${JSON.stringify(CLSX_VERSION_RANGE)},${eol}${indent}${indent}"tailwind-merge": ${JSON.stringify(TAILWIND_MERGE_VERSION_RANGE)}${eol}${indent}}`;
+        return {
+            nextSource: `${body}${block}${whitespace}${source.slice(closing)}`,
+            changed: true,
+            notes,
+        };
+    }
+    let nextSource = source;
+    if (!pkg.dependencies?.clsx)
+        nextSource = applyEdits(nextSource, modify(nextSource, ["dependencies", "clsx"], CLSX_VERSION_RANGE, { formattingOptions }));
+    if (!pkg.dependencies?.["tailwind-merge"])
+        nextSource = applyEdits(nextSource, modify(nextSource, ["dependencies", "tailwind-merge"], TAILWIND_MERGE_VERSION_RANGE, {
+            formattingOptions,
+        }));
+    return { nextSource, changed: true, notes };
+}

package/dist/project/tar-gz.d.ts

@@ -0,0 +1,12 @@
+/** Build a gzipped POSIX tar from in-memory files (test fixtures and unpacking). */
+export declare function createTarGz(files: Readonly<Record<string, string | Uint8Array>>): Uint8Array;
+export type ExtractedTarFiles = {
+    readonly files: Record<string, Uint8Array>;
+    readonly errors: string[];
+};
+/** Gunzip + unpack tar; reject absolute paths, `..`, and oversized archives. */
+export declare function extractTarGz(bytes: Uint8Array, limits: {
+    maxEntries: number;
+    maxExpandedBytes: number;
+}): ExtractedTarFiles;
+export declare function decodeUtf8(bytes: Uint8Array): string;

package/dist/project/tar-gz.js

@@ -0,0 +1,100 @@
+import { gzipSync, gunzipSync } from "node:zlib";
+const BLOCK = 512;
+function checksumHeader(header) {
+    let sum = 0;
+    for (let i = 0; i < BLOCK; i += 1)
+        sum += header[i] ?? 0;
+    return sum;
+}
+function writeOctal(buf, offset, length, value) {
+    const text = `${value.toString(8).padStart(length - 1, "0")}\0`;
+    buf.write(text.slice(0, length), offset, length, "utf8");
+}
+/** Build a gzipped POSIX tar from in-memory files (test fixtures and unpacking). */
+export function createTarGz(files) {
+    const parts = [];
+    const names = Object.keys(files).sort((a, b) => a.localeCompare(b));
+    for (const name of names) {
+        if (name.includes("..") || name.startsWith("/")) {
+            throw new Error(`unsafe tar path: ${name}`);
+        }
+        const raw = files[name];
+        const body = typeof raw === "string" ? Buffer.from(raw, "utf8") : Buffer.from(raw ?? []);
+        const header = Buffer.alloc(BLOCK, 0);
+        Buffer.from(name).copy(header, 0, 0, Math.min(name.length, 100));
+        writeOctal(header, 100, 8, 0o644);
+        writeOctal(header, 108, 8, 0);
+        writeOctal(header, 116, 8, 0);
+        writeOctal(header, 124, 12, body.byteLength);
+        writeOctal(header, 136, 12, 0);
+        header.write("        ", 148, 8, "utf8");
+        header[156] = 0x30;
+        header.write("ustar", 257, 5, "utf8");
+        header[262] = 0;
+        header.write("00", 263, 2, "utf8");
+        const sum = checksumHeader(header);
+        header.write(`${sum.toString(8).padStart(6, "0")}\0 `, 148, 8, "utf8");
+        parts.push(header, body);
+        const pad = (BLOCK - (body.byteLength % BLOCK)) % BLOCK;
+        if (pad > 0)
+            parts.push(Buffer.alloc(pad, 0));
+    }
+    parts.push(Buffer.alloc(BLOCK * 2, 0));
+    return gzipSync(Buffer.concat(parts), { level: 9 });
+}
+function readOctal(buf, offset, length) {
+    const raw = buf.subarray(offset, offset + length).toString("utf8").replace(/\0.*$/, "").trim();
+    if (!raw)
+        return 0;
+    return Number.parseInt(raw, 8);
+}
+/** Gunzip + unpack tar; reject absolute paths, `..`, and oversized archives. */
+export function extractTarGz(bytes, limits) {
+    const files = {};
+    const errors = [];
+    let data;
+    try {
+        data = gunzipSync(bytes);
+    }
+    catch {
+        return { files, errors: ["invalid gzip"] };
+    }
+    let offset = 0;
+    let entries = 0;
+    let expanded = 0;
+    while (offset + BLOCK <= data.byteLength) {
+        const header = data.subarray(offset, offset + BLOCK);
+        offset += BLOCK;
+        if (header.every((byte) => byte === 0))
+            break;
+        const name = header.subarray(0, 100).toString("utf8").replace(/\0.*$/, "").replace(/^\.\//, "");
+        const size = readOctal(header, 124, 12);
+        const type = header[156];
+        const padded = Math.ceil(size / BLOCK) * BLOCK;
+        const content = data.subarray(offset, offset + size);
+        offset += padded;
+        if (type !== 0 && type !== 0x30)
+            continue;
+        if (!name || name.endsWith("/"))
+            continue;
+        entries += 1;
+        if (entries > limits.maxEntries) {
+            errors.push(`too many entries (> ${limits.maxEntries})`);
+            break;
+        }
+        if (name.startsWith("/") || name.split("/").includes("..")) {
+            errors.push(`unsafe path "${name}"`);
+            continue;
+        }
+        expanded += content.byteLength;
+        if (expanded > limits.maxExpandedBytes) {
+            errors.push("expanded size exceeds limit");
+            break;
+        }
+        files[name] = new Uint8Array(content);
+    }
+    return { files, errors };
+}
+export function decodeUtf8(bytes) {
+    return Buffer.from(bytes).toString("utf8");
+}

package/dist/tui/primitives.d.ts

@@ -0,0 +1,36 @@
+/**
+ * CLI-04: TUI primitives with injected streams. Business modules never import
+ * this; command handlers inject their own streams. Non-TTY detection and
+ * cancellation are first-class. Avoids brittle terminal timing.
+ */
+export interface TuiStreams {
+    readonly isTTY: () => boolean;
+    readonly write: (text: string) => void;
+    readonly readLine: (prompt: string) => Promise<string>;
+    readonly readKey: () => Promise<string>;
+}
+export interface TuiDeps {
+    readonly streams: TuiStreams;
+    readonly signal?: AbortSignal;
+    /** `--yes`: skip confirmations without prompting. */
+    readonly yes?: boolean;
+}
+export type Choice<T> = {
+    readonly value: T;
+    readonly label: string;
+};
+export interface SelectOptions<T> {
+    readonly choices: readonly Choice<T>[];
+    readonly canCancel?: boolean;
+}
+export declare class CancelledError extends Error {
+    constructor();
+}
+/** Render a banner. No TTY required. */
+export declare function renderBanner(deps: TuiDeps, banner: string): void;
+/** Interactive single-choice selection; non-TTY rejects with guidance. */
+export declare function select<T>(deps: TuiDeps, prompt: string, options: SelectOptions<T>): Promise<T>;
+/** Yes/no confirmation; default from options. `--yes` skips the prompt. */
+export declare function confirm(deps: TuiDeps, prompt: string, defaultValue: boolean): Promise<boolean>;
+/** Masked key input (echo replaced with bullets). Non-TTY rejects. */
+export declare function maskedInput(deps: TuiDeps, prompt: string): Promise<string>;

package/dist/tui/primitives.js

@@ -0,0 +1,88 @@
+import { CliError } from "../errors/index.js";
+export class CancelledError extends Error {
+    constructor() {
+        super("cancelled");
+        this.name = "CancelledError";
+    }
+}
+function assertNotAborted(deps) {
+    if (deps.signal?.aborted)
+        throw new CancelledError();
+}
+/** Render a banner. No TTY required. */
+export function renderBanner(deps, banner) {
+    deps.streams.write(banner);
+    deps.streams.write("\n");
+}
+/** Interactive single-choice selection; non-TTY rejects with guidance. */
+export async function select(deps, prompt, options) {
+    assertNotAborted(deps);
+    if (!deps.streams.isTTY()) {
+        throw new CliError("NOT_TTY", "interactive selection requires a TTY; use a specific command or --json");
+    }
+    deps.streams.write(`${prompt}\n`);
+    options.choices.forEach((choice, i) => {
+        deps.streams.write(`  ${i + 1}) ${choice.label}\n`);
+    });
+    if (options.canCancel)
+        deps.streams.write("  0) Cancel\n");
+    for (;;) {
+        const line = (await deps.streams.readLine("> ")).trim();
+        assertNotAborted(deps);
+        if (options.canCancel && (line === "0" || line.toLowerCase() === "cancel")) {
+            throw new CancelledError();
+        }
+        const index = Number(line);
+        const choice = options.choices[index - 1];
+        if (choice)
+            return choice.value;
+        deps.streams.write("Invalid choice. Try again.\n");
+    }
+}
+/** Yes/no confirmation; default from options. `--yes` skips the prompt. */
+export async function confirm(deps, prompt, defaultValue) {
+    assertNotAborted(deps);
+    if (deps.yes)
+        return true;
+    if (!deps.streams.isTTY()) {
+        throw new CliError("NOT_TTY", "confirmation requires a TTY; pass --yes to skip");
+    }
+    for (;;) {
+        const line = (await deps.streams.readLine(`${prompt} [y/N] `)).trim().toLowerCase();
+        assertNotAborted(deps);
+        if (line === "y" || line === "yes")
+            return true;
+        if (line === "n" || line === "no")
+            return false;
+        if (line === "")
+            return defaultValue;
+        deps.streams.write("Please answer y or n.\n");
+    }
+}
+/** Masked key input (echo replaced with bullets). Non-TTY rejects. */
+export async function maskedInput(deps, prompt) {
+    assertNotAborted(deps);
+    if (!deps.streams.isTTY()) {
+        throw new CliError("NOT_TTY", "masked input requires a TTY");
+    }
+    deps.streams.write(prompt);
+    let value = "";
+    for (;;) {
+        const key = await deps.streams.readKey();
+        if (key === "\r" || key === "\n")
+            break;
+        if (key === "\u0003")
+            throw new CancelledError(); // Ctrl+C
+        if (key === "\u007f" || key === "\b") {
+            value = value.slice(0, -1);
+            deps.streams.write("\b \b");
+            continue;
+        }
+        if (key.length === 1 && key >= " ") {
+            value += key;
+            deps.streams.write("*");
+        }
+    }
+    deps.streams.write("\n");
+    return value;
+}

package/dist/ui/banner.d.ts

@@ -0,0 +1,11 @@
+export declare const MOEICONS_BANNER: string;
+export declare const CLI_NOTICE_LINES: readonly ["Run moeicons from your project root.", "React/Vue targets require the matching framework.", "Automatic Tailwind integration supports v3 only.", "Vanilla and Assets do not require React or Vue."];
+/** Visible terminal width: ANSI sequences and combining marks take no columns. */
+export declare function visibleWidth(value: string): number;
+/** Render an adaptive notice box without splitting ANSI escapes or Unicode characters. */
+export declare function renderNoticeBox(message: string | readonly string[], options?: {
+    readonly width?: number;
+    readonly unicode?: boolean;
+}): string;
+export declare function renderBannerText(): string;
+export declare const CLI_VERSION: string;

package/dist/ui/banner.js

@@ -0,0 +1,105 @@
+import packageJson from "../../package.json" with { type: "json" };
+/** ASCII banner generated by scripts/generate-banner.mjs (figlet, Standard font). */
+const slash = String.fromCharCode(92);
+export const MOEICONS_BANNER = [
+    "",
+    "  __  __  ___  _____ ___ ____ ___  _   _ ____",
+    ` |  ${slash}/  |/ _ ${slash}| ____|_ _/ ___/ _ ${slash}| ${slash} | / ___|`,
+    " | |" + slash + "/| | | | |  _|  | |  | | | |  " + slash + "| " + slash + "___ " + slash,
+    ` | |  | | |_| | |___ | | |__| |_| | |${slash}  |___) |`,
+    ` |_|  |_|${slash}___/|_____|___${slash}____${slash}___/|_| ${slash}_|____/`,
+    "",
+].join("\n");
+const ANSI_ESCAPE = new RegExp(`${String.fromCharCode(27)}\\[[0-?]*[ -/]*[@-~]`, "g");
+const COMBINING_MARK = /\p{Mark}/u;
+const CONTROL = /[\p{Cc}\p{Cf}]/u;
+const WIDE_CODEPOINT = "[" +
+    "\u1100-\u115f" + // Hangul jamo
+    "\u2e80-\u303e" + // CJK radicals, Kangxi, punctuation
+    "\u3041-\u33ff" + // Hiragana/Katakana, CJK symbols, enclosed
+    "\u3400-\u4dbf" + // CJK ext A
+    "\u4e00-\u9fff" + // CJK unified
+    "\ua000-\ua4cf" + // Yi
+    "\uac00-\ud7a3" + // Hangul syllables
+    "\uf900-\ufaff" + // CJK compat
+    "\ufe30-\ufe4f" + // CJK compat forms
+    "\uff00-\uff60" + // fullwidth forms
+    "\uffe0-\uffe6" + // fullwidth signs
+    "]";
+const WIDE_CHAR = new RegExp(WIDE_CODEPOINT, "u");
+export const CLI_NOTICE_LINES = [
+    "Run moeicons from your project root.",
+    "React/Vue targets require the matching framework.",
+    "Automatic Tailwind integration supports v3 only.",
+    "Vanilla and Assets do not require React or Vue.",
+];
+/** wcwidth-style display width for a single Unicode code point. */
+function codepointWidth(character) {
+    if (COMBINING_MARK.test(character))
+        return 0;
+    if (CONTROL.test(character))
+        return 0;
+    if (WIDE_CHAR.test(character))
+        return 2;
+    return 1;
+}
+function stripAnsi(value) {
+    return value.replace(ANSI_ESCAPE, "");
+}
+/** Visible terminal width: ANSI sequences and combining marks take no columns. */
+export function visibleWidth(value) {
+    let width = 0;
+    for (const character of stripAnsi(value))
+        width += codepointWidth(character);
+    return width;
+}
+const ANSI_OR_CHAR = new RegExp(`${String.fromCharCode(27)}\\[[0-?]*[ -/]*[@-~]|[\\s\\S]`, "gu");
+/** Truncate to `maxWidth` visible columns, preserving ANSI sequences seen so far. */
+function truncateLine(value, maxWidth) {
+    if (visibleWidth(value) <= maxWidth)
+        return value;
+    const budget = maxWidth - 1;
+    let result = "";
+    let width = 0;
+    for (const token of value.matchAll(ANSI_OR_CHAR)) {
+        const part = token[0];
+        if (part.startsWith(String.fromCharCode(27))) {
+            result += part;
+            continue;
+        }
+        const tokenWidth = codepointWidth(part);
+        if (width + tokenWidth > budget) {
+            result += "…";
+            break;
+        }
+        result += part;
+        width += tokenWidth;
+    }
+    return result;
+}
+/** Pad to `width` visible columns, ignoring ANSI escapes. */
+function padLine(value, width) {
+    const missing = width - visibleWidth(value);
+    return missing > 0 ? value + " ".repeat(missing) : value;
+}
+/** Render an adaptive notice box without splitting ANSI escapes or Unicode characters. */
+export function renderNoticeBox(message, options = {}) {
+    const lines = typeof message === "string" ? message.split("\n") : [...message];
+    const available = Math.max(4, options.width ?? 80);
+    const widest = lines.length > 0 ? Math.max(...lines.map(visibleWidth)) : 1;
+    const contentWidth = Math.min(Math.max(widest, 1), Math.max(1, available - 4));
+    const unicode = options.unicode ?? true;
+    const [top, side, bottom, topRight, bottomRight] = unicode
+        ? ["┌", "│", "└", "┐", "┘"]
+        : ["+", "|", "+", "+", "+"];
+    const horizontal = unicode ? "─" : "-";
+    return [
+        `${top}${horizontal.repeat(contentWidth + 2)}${topRight}`,
+        ...lines.map((line) => `${side} ${padLine(truncateLine(line, contentWidth), contentWidth)} ${side}`),
+        `${bottom}${horizontal.repeat(contentWidth + 2)}${bottomRight}`,
+    ].join("\n");
+}
+export function renderBannerText() {
+    return `${MOEICONS_BANNER}\n${renderNoticeBox(CLI_NOTICE_LINES)}\n`;
+}
+export const CLI_VERSION = packageJson.version;