@moewolf/moe-icons-cli 0.0.1

package/dist/core/free-download.js

@@ -0,0 +1,193 @@
+import { join } from "node:path";
+import { createHash } from "node:crypto";
+import { downloadArtifact, verifyArtifact } from "../project/install.js";
+import { decodeUtf8, extractTarGz } from "../project/tar-gz.js";
+import { catalog as bundledCatalog } from "../catalog/catalog.js";
+import { cacheKey, FREE_DOWNLOAD_HOSTS, githubReleaseAssetUrl, parseReleaseDescriptor, parseSha256Sidecar, } from "./release-descriptor.js";
+export const DESCRIPTOR_MAX_BYTES = 256 * 1024;
+export const ARTIFACT_MAX_BYTES = 64 * 1024 * 1024;
+export const DOWNLOAD_TIMEOUT_MS = 30_000;
+export const MAX_REDIRECTS = 5;
+export const DESCRIPTOR_NAME = "release-descriptor.json";
+export const DESCRIPTOR_SHA_NAME = "release-descriptor.json.sha256";
+function sha256Hex(bytes) {
+    return createHash("sha256").update(bytes).digest("hex");
+}
+function userAgent(cliVersion) {
+    return `moeicons/${cliVersion} (+https://github.com/moewolf-dev/moe-icons-cli)`;
+}
+function descriptorLimits(cliVersion, onProgress, fixtureBaseUrl, timeoutMs = DOWNLOAD_TIMEOUT_MS) {
+    return {
+        maxBytes: DESCRIPTOR_MAX_BYTES,
+        timeoutMs,
+        maxRedirects: MAX_REDIRECTS,
+        allowedHosts: fixtureBaseUrl ? [new URL(fixtureBaseUrl).host] : FREE_DOWNLOAD_HOSTS,
+        ...(fixtureBaseUrl ? { allowHttpLoopback: true } : {}),
+        userAgent: userAgent(cliVersion),
+        ...(onProgress ? { onProgress } : {}),
+    };
+}
+function artifactLimits(cliVersion, onProgress, fixtureBaseUrl, timeoutMs = DOWNLOAD_TIMEOUT_MS) {
+    return {
+        maxBytes: ARTIFACT_MAX_BYTES,
+        timeoutMs,
+        maxRedirects: MAX_REDIRECTS,
+        allowedHosts: fixtureBaseUrl ? [new URL(fixtureBaseUrl).host] : FREE_DOWNLOAD_HOSTS,
+        ...(fixtureBaseUrl ? { allowHttpLoopback: true } : {}),
+        userAgent: userAgent(cliVersion),
+        ...(onProgress ? { onProgress } : {}),
+    };
+}
+function mapDownloadError(code, message) {
+    if (code === "HTTP_ERROR" && / 404$/.test(message)) {
+        return { ok: false, reason: "not-found", message };
+    }
+    if (code === "NETWORK_ERROR")
+        return { ok: false, reason: "network", message };
+    return { ok: false, reason: "validation", message };
+}
+function readFixture(io, name) {
+    return io.readFileSync(join(io.fixtureDir ?? "", name));
+}
+export function artifactCachePath(cacheDir, fullVersion, sha256) {
+    return join(cacheDir, ...cacheKey(fullVersion, sha256).split("/"), "artifact.tgz");
+}
+function cachePath(io, fullVersion, sha256) {
+    return artifactCachePath(io.cacheDir, fullVersion, sha256);
+}
+async function loadBytes(io, filename, limits, tag) {
+    if (io.signal.aborted)
+        return { ok: false, reason: "cancelled", message: "download cancelled" };
+    if (io.fixtureDir) {
+        try {
+            return { ok: true, bytes: readFixture(io, filename) };
+        }
+        catch (error) {
+            return { ok: false, reason: "validation", message: error instanceof Error ? error.message : String(error) };
+        }
+    }
+    const url = io.fixtureBaseUrl ? new URL(filename, io.fixtureBaseUrl.endsWith("/") ? io.fixtureBaseUrl : `${io.fixtureBaseUrl}/`).toString() : githubReleaseAssetUrl(tag, filename);
+    const result = await downloadArtifact(url, limits, { fetchFn: io.fetchFn, signal: io.signal });
+    if (!result.ok)
+        return mapDownloadError(result.code, result.message);
+    return { ok: true, bytes: result.bytes };
+}
+function catalogFromArchive(artifactBytes, catalogFilename, expectedSha) {
+    const unpacked = extractTarGz(artifactBytes, { maxEntries: 20_000, maxExpandedBytes: ARTIFACT_MAX_BYTES });
+    if (unpacked.errors.length > 0) {
+        return { ok: false, reason: "validation", message: unpacked.errors[0] ?? "extract failed" };
+    }
+    const catalogBytes = unpacked.files[catalogFilename] ?? unpacked.files[`./${catalogFilename}`];
+    if (!catalogBytes) {
+        return { ok: false, reason: "validation", message: `artifact is missing ${catalogFilename}` };
+    }
+    const actual = sha256Hex(catalogBytes);
+    if (actual !== expectedSha) {
+        return {
+            ok: false,
+            reason: "checksum-mismatch",
+            message: `catalog SHA-256 mismatch: expected ${expectedSha}, got ${actual}`,
+        };
+    }
+    return { ok: true, json: decodeUtf8(catalogBytes) };
+}
+/**
+ * Fetch descriptor sidecar → verify descriptor → download free.filename from
+ * the descriptor (never guessed) → verify archive + nested catalog checksums.
+ * Local `fixtureDir` stands in for a GitHub Release directory.
+ */
+export async function downloadFreeRelease(io, sourceVersion) {
+    if (io.signal.aborted)
+        return { ok: false, reason: "cancelled", message: "download cancelled" };
+    const tag = `v${sourceVersion}`;
+    const shaFile = await loadBytes(io, DESCRIPTOR_SHA_NAME, descriptorLimits(io.cliVersion, io.onProgress, io.fixtureBaseUrl, io.timeoutMs), tag);
+    if (!shaFile.ok) {
+        if (!io.fixtureDir && shaFile.reason === "network") {
+            return { ok: false, reason: "offline-no-cache", message: shaFile.message };
+        }
+        return shaFile;
+    }
+    let expectedDescriptorSha;
+    try {
+        expectedDescriptorSha = parseSha256Sidecar(decodeUtf8(shaFile.bytes));
+    }
+    catch (error) {
+        return { ok: false, reason: "validation", message: error instanceof Error ? error.message : String(error) };
+    }
+    const descriptorFile = await loadBytes(io, DESCRIPTOR_NAME, descriptorLimits(io.cliVersion, io.onProgress, io.fixtureBaseUrl, io.timeoutMs), tag);
+    if (!descriptorFile.ok)
+        return descriptorFile;
+    const actualDescriptorSha = sha256Hex(descriptorFile.bytes);
+    if (actualDescriptorSha !== expectedDescriptorSha) {
+        return {
+            ok: false,
+            reason: "checksum-mismatch",
+            message: `descriptor SHA-256 mismatch: expected ${expectedDescriptorSha}, got ${actualDescriptorSha}`,
+        };
+    }
+    let descriptor;
+    try {
+        descriptor = parseReleaseDescriptor(descriptorFile.bytes);
+    }
+    catch (error) {
+        return { ok: false, reason: "validation", message: error instanceof Error ? error.message : String(error) };
+    }
+    if (descriptor.fullVersion !== sourceVersion) {
+        return {
+            ok: false,
+            reason: "validation",
+            message: `descriptor fullVersion ${descriptor.fullVersion} does not match catalog sourceVersion ${sourceVersion}`,
+        };
+    }
+    const artifactCache = cachePath(io, descriptor.fullVersion, descriptor.free.sha256);
+    if (io.existsSync(artifactCache)) {
+        const cached = io.readFileSync(artifactCache);
+        const verified = verifyArtifact(cached, descriptor.free.sha256);
+        if (verified.ok) {
+            const catalog = catalogFromArchive(cached, descriptor.catalog.filename, descriptor.catalog.sha256);
+            if (!catalog.ok)
+                return catalog;
+            return {
+                ok: true,
+                descriptor,
+                descriptorSha256: actualDescriptorSha,
+                artifactBytes: cached,
+                catalogJson: catalog.json,
+                cacheHit: true,
+                tag,
+            };
+        }
+    }
+    const artifact = await loadBytes(io, descriptor.free.filename, artifactLimits(io.cliVersion, io.onProgress, io.fixtureBaseUrl, io.timeoutMs), tag);
+    if (!artifact.ok) {
+        if (!io.fixtureDir && artifact.reason === "network") {
+            return { ok: false, reason: "offline-no-cache", message: artifact.message };
+        }
+        return artifact;
+    }
+    const verified = verifyArtifact(artifact.bytes, descriptor.free.sha256);
+    if (!verified.ok) {
+        return {
+            ok: false,
+            reason: "checksum-mismatch",
+            message: `free artifact SHA-256 mismatch: expected ${descriptor.free.sha256}, got ${verified.actual}`,
+        };
+    }
+    const catalog = catalogFromArchive(artifact.bytes, descriptor.catalog.filename, descriptor.catalog.sha256);
+    if (!catalog.ok)
+        return catalog;
+    io.mkdirSync(join(artifactCache, ".."));
+    io.writeFileSync(artifactCache, artifact.bytes);
+    return {
+        ok: true,
+        descriptor,
+        descriptorSha256: actualDescriptorSha,
+        artifactBytes: artifact.bytes,
+        catalogJson: catalog.json,
+        cacheHit: false,
+        tag,
+    };
+}
+export function bundledSourceVersion() {
+    return bundledCatalog.sourceVersion;
+}

package/dist/core/generate.d.ts

@@ -0,0 +1,33 @@
+import { type TransactionalFsWithCopy } from "../project/install.js";
+import type { CommandContext } from "./context.js";
+import type { Target } from "../commands/parser.js";
+export type GenerateResult = {
+    readonly ok: true;
+    readonly files: readonly string[];
+    readonly warnings?: readonly string[];
+    readonly notes?: readonly string[];
+} | {
+    readonly ok: false;
+    readonly reason: string;
+    readonly errors?: readonly string[];
+    readonly code?: string;
+};
+/**
+ * Load installed artifact bytes for generate. Prefers `.moeicons/artifact/<target>/`
+ * when that subtree already contains the assets the generator needs (assets target).
+ * Vanilla (and bitmap themes on react/vue) need the full cached archive so
+ * `assets/` is available — the installed package subtree alone is not enough.
+ */
+export declare function loadArchiveFiles(projectRoot: string, env: Readonly<Record<string, string | undefined>>, fs_: Pick<TransactionalFsWithCopy, "readFileSync" | "existsSync" | "readdirSync">, injected?: Readonly<Record<string, Uint8Array>>): {
+    readonly ok: true;
+    readonly files: Readonly<Record<string, Uint8Array>>;
+} | {
+    readonly ok: false;
+    readonly reason: string;
+};
+export declare function runGenerateUseCase(context: CommandContext, fs_: TransactionalFsWithCopy, options?: {
+    readonly noTailwind?: boolean;
+    readonly target?: Target;
+    readonly archiveFiles?: Readonly<Record<string, Uint8Array>>;
+    readonly reconcileInstalled?: boolean;
+}): Promise<GenerateResult>;

package/dist/core/generate.js

@@ -0,0 +1,285 @@
+import { join, relative, resolve } from "node:path";
+import { homedir } from "node:os";
+import { executeGeneratedFilesDir, executeManagedReconcile, } from "../project/install.js";
+import { detectProject } from "../project/detect.js";
+import { readMoeiconsConfig } from "../project/config.js";
+import { planGeneratedFiles } from "../generator/generate.js";
+import { ensureClassMergeDependencies, planTailwindIntegration } from "../project/tailwind.js";
+import { CliError, isCliError } from "../errors/index.js";
+import { extractTarGz } from "../project/tar-gz.js";
+import { artifactCachePath } from "./free-download.js";
+import { resolveThemes } from "../generator/theme-resolve.js";
+import { parseInstallMetadata, serializeInstallMetadata, sha256Bytes, } from "../project/install-metadata.js";
+import { withProjectLockSync } from "../project/project-lock.js";
+function hasBitmapThemes(config) {
+    const resolved = resolveThemes(config);
+    return resolved.ok && resolved.themes.some((theme) => theme.kind === "bitmap");
+}
+/** Vanilla/Assets generate from raw SVG; bitmap themes need variant binaries. */
+function needsArchiveFiles(config) {
+    if (config.target === "vanilla" || config.target === "assets")
+        return true;
+    return hasBitmapThemes(config);
+}
+function archiveHasAssetsManifest(files) {
+    return Object.keys(files).some((path) => /(?:^|\/)assets\/manifest\.json$/.test(path));
+}
+function missingArchiveMessage(config) {
+    if (config.target === "vanilla" || config.target === "assets") {
+        return `${config.target} target requires an installed artifact; run \`moeicons install\` first`;
+    }
+    return "bitmap themes require a downloaded free artifact; run `moeicons install` or set MOEICONS_BITMAP_ARCHIVE";
+}
+function readInstallMetadata(projectRoot, readFileSync, existsSync) {
+    const path = join(projectRoot, ".moeicons", "install-metadata.json");
+    if (!existsSync(path))
+        return undefined;
+    try {
+        const parsed = JSON.parse(readFileSync(path, "utf8"));
+        return {
+            ...(typeof parsed.artifactVersion === "string"
+                ? { artifactVersion: parsed.artifactVersion }
+                : {}),
+            ...(typeof parsed.artifactSha256 === "string"
+                ? { artifactSha256: parsed.artifactSha256 }
+                : {}),
+            ...(typeof parsed.target === "string" &&
+                ["react", "vue", "vanilla", "assets"].includes(parsed.target)
+                ? { target: parsed.target }
+                : {}),
+        };
+    }
+    catch {
+        return undefined;
+    }
+}
+function readBinaryFile(fs_, path) {
+    const data = fs_.readFileSync(path);
+    return typeof data === "string" ? Buffer.from(data, "utf8") : new Uint8Array(data);
+}
+/**
+ * Load installed artifact bytes for generate. Prefers `.moeicons/artifact/<target>/`
+ * when that subtree already contains the assets the generator needs (assets target).
+ * Vanilla (and bitmap themes on react/vue) need the full cached archive so
+ * `assets/` is available — the installed package subtree alone is not enough.
+ */
+export function loadArchiveFiles(projectRoot, env, fs_, injected) {
+    if (injected)
+        return { ok: true, files: injected };
+    const fixtureTgz = env.MOEICONS_BITMAP_ARCHIVE;
+    if (fixtureTgz && fs_.existsSync(fixtureTgz)) {
+        const unpacked = extractTarGz(readBinaryFile(fs_, fixtureTgz), {
+            maxEntries: 20_000,
+            maxExpandedBytes: 64 * 1024 * 1024,
+        });
+        if (unpacked.errors.length > 0)
+            return { ok: false, reason: unpacked.errors[0] ?? "invalid bitmap archive fixture" };
+        return { ok: true, files: unpacked.files };
+    }
+    const meta = readInstallMetadata(projectRoot, fs_.readFileSync, fs_.existsSync);
+    if (meta?.target) {
+        const subtreeRoot = join(projectRoot, ".moeicons", "artifact", meta.target);
+        if (fs_.existsSync(subtreeRoot)) {
+            const files = {};
+            const walk = (dir, prefix) => {
+                let entries;
+                try {
+                    entries = fs_.readdirSync(dir, { withFileTypes: true });
+                }
+                catch {
+                    return;
+                }
+                for (const entry of entries.sort((a, b) => a.name.localeCompare(b.name))) {
+                    const full = join(dir, entry.name);
+                    const rel = prefix ? `${prefix}/${entry.name}` : entry.name;
+                    if (entry.isDirectory()) {
+                        walk(full, rel);
+                        continue;
+                    }
+                    if (!entry.isFile())
+                        continue;
+                    const data = readBinaryFile(fs_, full);
+                    files[`${meta.target}/${rel}`] = data;
+                }
+            };
+            walk(subtreeRoot, "");
+            // assets install lands the raw tree; reuse it. Package subtrees (react/vue/
+            // vanilla) do not contain assets/manifest.json — fall through to the cache.
+            if (Object.keys(files).length > 0 && (meta.target === "assets" || archiveHasAssetsManifest(files))) {
+                return { ok: true, files };
+            }
+        }
+    }
+    const cacheDir = env.MOEICONS_CACHE_DIR ?? join(homedir(), ".moeicons", "cache");
+    if (meta?.artifactVersion && meta.artifactSha256) {
+        const cached = artifactCachePath(cacheDir, meta.artifactVersion, meta.artifactSha256);
+        if (fs_.existsSync(cached)) {
+            const unpacked = extractTarGz(readBinaryFile(fs_, cached), {
+                maxEntries: 20_000,
+                maxExpandedBytes: 64 * 1024 * 1024,
+            });
+            if (unpacked.errors.length > 0)
+                return { ok: false, reason: unpacked.errors[0] ?? "invalid cached artifact" };
+            return { ok: true, files: unpacked.files };
+        }
+    }
+    return { ok: false, reason: "installed artifact not found" };
+}
+/**
+ * B5: switching the configured target over an existing install is a destructive
+ * migration (generated files are replaced and the install subtree changes).
+ * Interactive TTY prompts for explicit confirmation; non-interactive/JSON mode
+ * fails with VALIDATION_ERROR unless `--yes` was passed (the non-interactive
+ * UI resolves `--yes` confirmations to true). Fresh projects with no install
+ * metadata never prompt.
+ */
+async function confirmTargetSwitch(context, installedTarget, configuredTarget) {
+    const message = `Existing install targets "${installedTarget}" but the config now targets "${configuredTarget}". ` +
+        "Switching targets is a destructive migration that replaces generated files. Continue?";
+    try {
+        return (await context.ui.confirm(message, context.signal)) === true;
+    }
+    catch (error) {
+        if (isCliError(error) && error.code === "NOT_TTY") {
+            throw new CliError("VALIDATION_ERROR", `target switch from "${installedTarget}" to "${configuredTarget}" is destructive and requires confirmation; pass --yes in non-interactive mode`);
+        }
+        throw error;
+    }
+}
+export async function runGenerateUseCase(context, fs_, options = {}) {
+    const project = detectProject(context.cwd);
+    if (!project)
+        return { ok: false, reason: "no-project" };
+    const loaded = readMoeiconsConfig(project.root);
+    if (loaded.kind !== "ok")
+        return { ok: false, reason: `config state: ${loaded.kind}` };
+    const effectiveConfig = options.target
+        ? { ...loaded.config, target: options.target }
+        : loaded.config;
+    const installedMeta = readInstallMetadata(project.root, fs_.readFileSync, fs_.existsSync);
+    if (installedMeta?.target && installedMeta.target !== effectiveConfig.target) {
+        const confirmed = await confirmTargetSwitch(context, installedMeta.target, effectiveConfig.target);
+        if (!confirmed)
+            return {
+                ok: false,
+                reason: "cancelled",
+                errors: [`target switch from "${installedMeta.target}" to "${effectiveConfig.target}" cancelled`],
+            };
+    }
+    let archiveFiles = options.archiveFiles;
+    if (needsArchiveFiles(effectiveConfig) && archiveFiles === undefined) {
+        const loadedArchive = loadArchiveFiles(project.root, context.env, fs_, undefined);
+        if (!loadedArchive.ok) {
+            return {
+                ok: false,
+                reason: "validation",
+                errors: [missingArchiveMessage(effectiveConfig)],
+            };
+        }
+        archiveFiles = loadedArchive.files;
+    }
+    const plan = planGeneratedFiles(effectiveConfig, effectiveConfig.outputDir, archiveFiles ? { archiveFiles } : {});
+    if (!plan.ok)
+        return { ok: false, reason: "validation", errors: plan.errors };
+    const notes = [];
+    const sideFiles = [];
+    try {
+        const tw = planTailwindIntegration(project.root, loaded.config.outputDir, {
+            noTailwind: options.noTailwind === true,
+            target: effectiveConfig.target,
+        });
+        notes.push(...tw.notes);
+        sideFiles.push(...tw.files);
+    }
+    catch (error) {
+        if (isCliError(error) && error.code === "TAILWIND_VERSION_UNSUPPORTED") {
+            return { ok: false, reason: error.message, code: error.code };
+        }
+        throw error;
+    }
+    const pkgPath = join(project.root, "package.json");
+    if (fs_.existsSync(pkgPath)) {
+        const pkgSource = fs_.readFileSync(pkgPath, "utf8");
+        const target = effectiveConfig.target;
+        const deps = target === "react" || target === "vue"
+            ? ensureClassMergeDependencies(pkgSource)
+            : {
+                nextSource: pkgSource,
+                changed: false,
+                notes: [`skipped class merge dependencies for ${target} target`],
+            };
+        notes.push(...deps.notes);
+        if (deps.changed) {
+            sideFiles.push({ path: pkgPath, content: deps.nextSource });
+        }
+    }
+    try {
+        if (options.reconcileInstalled) {
+            const metadataPath = join(project.root, ".moeicons", "install-metadata.json");
+            if (!fs_.existsSync(metadataPath))
+                return {
+                    ok: false,
+                    reason: "managed install metadata is missing; run repair or reinstall",
+                };
+            const metadata = parseInstallMetadata(fs_.readFileSync(metadataPath, "utf8"));
+            if (!metadata || metadata.tier !== loaded.config.tier)
+                return {
+                    ok: false,
+                    reason: "managed install metadata is invalid or does not match config tier; run repair or reinstall",
+                };
+            for (const [managedPath, expected] of Object.entries(metadata.managedFiles)) {
+                const absolute = join(project.root, managedPath);
+                if (!fs_.existsSync(absolute) ||
+                    sha256Bytes(fs_.readFileSync(absolute)) !== expected) {
+                    return { ok: false, reason: `managed file was modified or removed: ${managedPath}` };
+                }
+            }
+            if (metadata.managedFiles[".moeicons/catalog.json"] !== metadata.catalogSha256)
+                return {
+                    ok: false,
+                    reason: "managed catalog hash is inconsistent; run repair or reinstall",
+                };
+            const outputPrefix = loaded.config.outputDir.replace(/\\/g, "/").replace(/\/$/, "") + "/";
+            const generated = Object.fromEntries(plan.files.map((file) => [file.path.replace(/\\/g, "/"), file.content]));
+            const nextManaged = {};
+            for (const [managedPath, hash] of Object.entries(metadata.managedFiles))
+                if (!managedPath.startsWith(outputPrefix))
+                    nextManaged[managedPath] = hash;
+            for (const [path, content] of Object.entries(generated))
+                nextManaged[path] = sha256Bytes(content);
+            const nextMetadata = { ...metadata, managedFiles: nextManaged };
+            const writes = { ...generated };
+            for (const file of sideFiles) {
+                const absolute = resolve(file.path);
+                const rel = relative(project.root, absolute).replace(/\\/g, "/");
+                if (!rel || rel.startsWith("../") || rel === "..")
+                    return { ok: false, reason: `side file escapes project: ${file.path}` };
+                writes[rel] = file.content;
+            }
+            writes[".moeicons/install-metadata.json"] = serializeInstallMetadata(nextMetadata);
+            const stale = Object.keys(metadata.managedFiles).filter((path) => path.startsWith(outputPrefix) && !(path in generated));
+            withProjectLockSync(project.root, "reload", () => executeManagedReconcile(project.root, writes, stale, fs_));
+            return {
+                ok: true,
+                files: plan.files.map((file) => file.path),
+                ...(loaded.warnings.length > 0 || notes.length > 0
+                    ? { warnings: [...loaded.warnings, ...notes] }
+                    : {}),
+            };
+        }
+        executeGeneratedFilesDir(plan.files, project.root, loaded.config.outputDir, fs_);
+        for (const file of sideFiles) {
+            fs_.writeFileSync(file.path, file.content);
+        }
+        return {
+            ok: true,
+            files: plan.files.map((file) => file.path),
+            ...(loaded.warnings.length > 0 || notes.length > 0
+                ? { warnings: [...loaded.warnings, ...notes] }
+                : {}),
+        };
+    }
+    catch (error) {
+        return { ok: false, reason: error instanceof Error ? error.message : String(error) };
+    }
+}

package/dist/core/icon-names.d.ts

@@ -0,0 +1,14 @@
+/**
+ * Canonical iconId → public name mapping.
+ *
+ * Must stay equivalent to moe-icons-code-library `scripts/generator-core.cjs`
+ * (`toComponentName` / `toExportName` / `reportNameCollisions`). The library
+ * keeps camelCase exports; CLI proxies keep PascalCase. Registry imports use
+ * an explicit alias between the two.
+ */
+/** Library/file/proxy PascalCase: `ui-search` → `UiSearch`. */
+export declare function toProxyName(iconId: string): string;
+/** Published library camelCase export: `ui-search` → `uiSearch`. */
+export declare function toLibraryExportName(iconId: string): string;
+export declare function reportProxyNameCollisions(iconIds: readonly string[]): string[];
+export declare function reportLibraryExportNameCollisions(iconIds: readonly string[]): string[];

package/dist/core/icon-names.js

@@ -0,0 +1,54 @@
+/**
+ * Canonical iconId → public name mapping.
+ *
+ * Must stay equivalent to moe-icons-code-library `scripts/generator-core.cjs`
+ * (`toComponentName` / `toExportName` / `reportNameCollisions`). The library
+ * keeps camelCase exports; CLI proxies keep PascalCase. Registry imports use
+ * an explicit alias between the two.
+ */
+const RESERVED_IDENTIFIERS = /^(?:default|class|function|var|let|const|new|return|delete|import|export)$/;
+function nameSegments(value) {
+    return String(value)
+        .normalize("NFKD")
+        .split("")
+        .filter((character) => character.charCodeAt(0) <= 0x7f)
+        .join("")
+        .split("-")
+        .filter(Boolean)
+        .map((segment) => segment.replace(/[^A-Za-z0-9_$]/g, ""));
+}
+/** Library/file/proxy PascalCase: `ui-search` → `UiSearch`. */
+export function toProxyName(iconId) {
+    const segments = nameSegments(iconId);
+    let result = segments.map((segment) => segment.charAt(0).toUpperCase() + segment.slice(1)).join("") || "Icon";
+    if (/^[0-9]/.test(result) || RESERVED_IDENTIFIERS.test(result.toLowerCase())) {
+        result = `Icon${result}`;
+    }
+    return result;
+}
+/** Published library camelCase export: `ui-search` → `uiSearch`. */
+export function toLibraryExportName(iconId) {
+    const component = toProxyName(iconId);
+    return component.charAt(0).toLowerCase() + component.slice(1);
+}
+export function reportProxyNameCollisions(iconIds) {
+    return reportCollisions(iconIds, toProxyName, "PascalCase");
+}
+export function reportLibraryExportNameCollisions(iconIds) {
+    return reportCollisions(iconIds, toLibraryExportName, "library export");
+}
+function reportCollisions(iconIds, nameOf, kind) {
+    const seen = new Map();
+    const collisions = [];
+    for (const id of iconIds) {
+        const name = nameOf(id);
+        const existing = seen.get(name);
+        if (existing) {
+            collisions.push(`duplicate ${kind} name "${name}" from "${existing}" and "${id}"`);
+        }
+        else {
+            seen.set(name, id);
+        }
+    }
+    return collisions;
+}

package/dist/core/init.d.ts

@@ -0,0 +1,12 @@
+import { type TransactionalFs } from "../project/install.js";
+import type { CommandContext } from "./context.js";
+import type { Target } from "../commands/parser.js";
+export type InitResult = {
+    readonly ok: true;
+    readonly created: string;
+} | {
+    readonly ok: false;
+    readonly reason: "no-project" | "exists" | "write-failed";
+    readonly path?: string;
+};
+export declare function runInitUseCase(context: CommandContext, fs_: TransactionalFs, target?: Target): InitResult;

package/dist/core/init.js

@@ -0,0 +1,23 @@
+import { join } from "node:path";
+import { createFileIfAbsent } from "../project/install.js";
+import { detectProject } from "../project/detect.js";
+import { findConfigFile, renderMoeiconsConfigJsonc } from "../project/config.js";
+export function runInitUseCase(context, fs_, target) {
+    const project = detectProject(context.cwd);
+    if (!project)
+        return { ok: false, reason: "no-project" };
+    if (findConfigFile(project.root))
+        return { ok: false, reason: "exists" };
+    const configPath = join(project.root, "moeicons.config.jsonc");
+    try {
+        const created = createFileIfAbsent(configPath, renderMoeiconsConfigJsonc({
+            target: target ?? (project.framework === "vue" ? "vue" : "react"),
+        }), fs_);
+        return created
+            ? { ok: true, created: configPath }
+            : { ok: false, reason: "exists", path: configPath };
+    }
+    catch {
+        return { ok: false, reason: "write-failed", path: configPath };
+    }
+}