@moewolf/moe-icons-cli 0.0.1 → 0.0.2

package/dist/project/anchors/apply.js

@@ -0,0 +1,65 @@
+import { realpathSync, readdirSync, copyFileSync } from "node:fs";
+import { executeManagedReconcile, safeManagedPath } from "../install.js";
+export function applyPlannedChanges(projectRoot, changes, fs_) {
+    const seen = new Map();
+    const foldedPaths = new Map();
+    for (const change of changes) {
+        if (seen.has(change.path))
+            return { ok: false, message: `duplicate planned path: ${change.path}` };
+        const folded = change.path.toLowerCase();
+        const collision = foldedPaths.get(folded);
+        if (collision)
+            return { ok: false, message: `case-insensitive planned path collision: ${collision}, ${change.path}` };
+        foldedPaths.set(folded, change.path);
+        seen.set(change.path, change);
+    }
+    for (const [folded, path] of foldedPaths) {
+        let parent = folded;
+        while (parent.includes("/")) {
+            parent = parent.slice(0, parent.lastIndexOf("/"));
+            const collision = foldedPaths.get(parent);
+            if (collision)
+                return { ok: false, message: `planned file and directory paths collide: ${collision}, ${path}` };
+        }
+    }
+    const entries = [...seen.values()];
+    const root = realpathSync(projectRoot);
+    const targetFor = (path) => safeManagedPath(root, path).target;
+    let pending;
+    try {
+        pending = entries.filter((entry) => {
+            const full = targetFor(entry.path);
+            const current = fs_.existsSync(full) ? fs_.readTextFileSync(full) : undefined;
+            if (current === entry.after)
+                return false;
+            if (current !== entry.before)
+                throw new Error(`file changed since planning: ${entry.path}`);
+            return true;
+        });
+        if (!pending.length)
+            return { ok: true, alreadyConfigured: true, written: [] };
+    }
+    catch (error) {
+        return { ok: false, message: error instanceof Error ? error.message : String(error) };
+    }
+    const writes = Object.fromEntries(pending.map((entry) => [entry.path, entry.after]));
+    const expectedText = Object.fromEntries(pending.map((entry) => [entry.path, entry.before]));
+    const transactionFs = {
+        existsSync: fs_.existsSync,
+        readFileSync: ((path) => fs_.readTextFileSync(path)),
+        mkdirSync: fs_.mkdirSync,
+        writeFileSync: ((path, content) => fs_.writeTextFileSync(path, String(content))),
+        renameSync: fs_.renameSync,
+        rmSync: fs_.rmSync,
+        readdirSync,
+        copyFileSync,
+    };
+    try {
+        executeManagedReconcile(root, writes, [], transactionFs, { expectedText });
+    }
+    catch (error) {
+        const reason = error instanceof Error ? error.message : String(error);
+        return { ok: false, message: reason.includes("original files retained at") ? `recovery incomplete; ${reason}` : reason };
+    }
+    return { ok: true, alreadyConfigured: false, written: pending.map((e) => e.path) };
+}

package/dist/project/anchors/diagnose.d.ts

@@ -0,0 +1,26 @@
+import type { IconCatalog } from "../../catalog/catalog.js";
+import type { DiagnosticReport, PlannedFileChange } from "./types.js";
+import { type DetectorIo } from "./helpers.js";
+/**
+ * Four-anchor orchestrator (E2E-B2..B5). Runs the fixed probe order and returns
+ * a stable DiagnosticReport. This function is read-only: it never writes. Callers
+ * decide how to render or apply `fixes`.
+ */
+export interface DiagnoseOptions {
+    readonly cwd: string;
+    readonly sourceCatalog?: IconCatalog | undefined;
+    readonly io?: DetectorIo;
+    /** Confirmed config integration paths, when previously stored in config. */
+    readonly confirmed?: {
+        readonly adapter?: string;
+        readonly entry?: string;
+        readonly style?: string;
+    };
+}
+export interface DiagnoseOutcome {
+    readonly ok: boolean;
+    readonly report: DiagnosticReport;
+    /** Combined, deduplicated, ordered fixes across anchors. */
+    readonly fixes: readonly PlannedFileChange[];
+}
+export declare function diagnoseProject(options: DiagnoseOptions): DiagnoseOutcome;

package/dist/project/anchors/diagnose.js

@@ -0,0 +1,90 @@
+import { dirname } from "node:path";
+import { realDetectorIo } from "./helpers.js";
+import { inspectProjectManifest } from "./project-manifest.js";
+import { inspectMoeiconsConfig } from "./moeicons-config.js";
+import { inspectApplicationAnchor } from "./application.js";
+import { inspectStyleAnchor } from "./style.js";
+import { readMoeiconsConfig } from "../config.js";
+export function diagnoseProject(options) {
+    const io = options.io ?? realDetectorIo;
+    const manifest = inspectProjectManifest({ cwd: options.cwd, io });
+    const adapterLine = manifest.evidence.find((line) => line.startsWith("adapter: "));
+    const rawAdapter = adapterLine ? adapterLine.slice("adapter: ".length) : undefined;
+    const adapter = rawAdapter && rawAdapter !== "unknown" && !rawAdapter.startsWith("ambiguous")
+        ? rawAdapter
+        : undefined;
+    let config;
+    let application;
+    let style;
+    if (manifest.status === "missing" || manifest.status === "invalid") {
+        config = {
+            kind: "config",
+            status: "not-required",
+            candidates: [],
+            evidence: ["no writable project manifest; config anchor not evaluated"],
+            fixes: [],
+        };
+        application = {
+            kind: "application",
+            status: "not-required",
+            candidates: [],
+            evidence: ["no writable project manifest; application anchor not evaluated"],
+            fixes: [],
+        };
+        style = {
+            kind: "style",
+            status: "not-required",
+            candidates: [],
+            evidence: ["no writable project manifest; style anchor not evaluated"],
+            fixes: [],
+        };
+    }
+    else {
+        const root = manifest.path ? dirname(manifest.path) : options.cwd;
+        const loaded = readMoeiconsConfig(root, options.sourceCatalog);
+        const confirmed = loaded.kind === "ok" ? loaded.config.integration : undefined;
+        const effectiveAdapter = options.confirmed?.adapter ?? confirmed?.adapter ?? adapter;
+        const confirmedEntry = options.confirmed?.entry ?? confirmed?.entry;
+        const confirmedStyle = options.confirmed?.style ?? confirmed?.style;
+        const assetsOnly = effectiveAdapter === "assets-only" || loaded.kind === "ok" && loaded.config.target === "assets";
+        config = inspectMoeiconsConfig({
+            root,
+            io,
+            sourceCatalog: options.sourceCatalog,
+            ...(effectiveAdapter && effectiveAdapter !== "assets-only" ? { adapter: effectiveAdapter } : {}),
+            assetsOnly,
+            ambiguous: manifest.evidence.some((line) => line.startsWith("adapter ambiguous:")),
+        });
+        application = inspectApplicationAnchor({
+            root,
+            io,
+            ...(effectiveAdapter ? { adapter: effectiveAdapter } : {}),
+            assetsOnly,
+            ...(loaded.kind === "ok" ? { outputDir: loaded.config.outputDir } : {}),
+            ...(confirmedEntry ? { confirmedEntry } : {}),
+        });
+        style = inspectStyleAnchor({
+            root,
+            io,
+            assetsOnly,
+            ...(confirmedStyle ? { confirmedStyle } : {}),
+        });
+    }
+    const report = {
+        ...(manifest.status === "ok" && manifest.path ? { projectRoot: dirname(manifest.path) } : {}),
+        anchors: [manifest, config, application, style],
+    };
+    const seen = new Set();
+    const fixes = [];
+    for (const anchor of report.anchors) {
+        for (const fix of anchor.fixes) {
+            const key = `${fix.kind}:${fix.path}`;
+            if (seen.has(key))
+                continue;
+            seen.add(key);
+            fixes.push(fix);
+        }
+    }
+    const ok = report.anchors.every((anchor) => anchor.kind === "style" || anchor.status === "ok" || anchor.status === "not-required");
+    return { ok, report, fixes };
+}

package/dist/project/anchors/helpers.d.ts

@@ -0,0 +1,20 @@
+import { existsSync } from "node:fs";
+import type { AnchorResult, PlannedFileChange } from "./types.js";
+/**
+ * Read-only detector io. Detectors never write: they accept only read primitives
+ * so a detector cannot be coerced into mutating a project.
+ */
+export interface DetectorIo {
+    readonly existsSync: typeof existsSync;
+    readonly readFileSync: (path: string) => string;
+}
+export declare const realDetectorIo: DetectorIo;
+export declare function isRecord(value: unknown): value is Record<string, unknown>;
+/** Read a JSON file safely; returns undefined on parse/io error. */
+export declare function readJsonSafe(io: DetectorIo, file: string): Record<string, unknown> | undefined;
+/** Walk upward from startDir to the nearest directory containing package.json. */
+export declare function findPackageJsonDir(io: DetectorIo, startDir: string): string | undefined;
+/** Package manager precedence with ambiguity -> unknown (never guesses). */
+export declare function detectPackageManager(io: DetectorIo, root: string): string;
+export declare function okResult(kind: AnchorResult["kind"], patch: Partial<AnchorResult>): AnchorResult;
+export declare function createFileFix(path: string, content: string): PlannedFileChange;

package/dist/project/anchors/helpers.js

@@ -0,0 +1,55 @@
+import { existsSync, readFileSync } from "node:fs";
+import { join, dirname } from "node:path";
+export const realDetectorIo = {
+    existsSync,
+    readFileSync: (path) => readFileSync(path, "utf8"),
+};
+export function isRecord(value) {
+    return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+/** Read a JSON file safely; returns undefined on parse/io error. */
+export function readJsonSafe(io, file) {
+    if (!io.existsSync(file))
+        return undefined;
+    try {
+        const raw = JSON.parse(io.readFileSync(file));
+        return isRecord(raw) ? raw : undefined;
+    }
+    catch {
+        return undefined;
+    }
+}
+/** Walk upward from startDir to the nearest directory containing package.json. */
+export function findPackageJsonDir(io, startDir) {
+    let dir = startDir;
+    for (;;) {
+        if (io.existsSync(join(dir, "package.json")))
+            return dir;
+        const parent = dirname(dir);
+        if (parent === dir)
+            return undefined;
+        dir = parent;
+    }
+}
+/** Package manager precedence with ambiguity -> unknown (never guesses). */
+export function detectPackageManager(io, root) {
+    const pnpm = io.existsSync(join(root, "pnpm-lock.yaml"));
+    const yarn = io.existsSync(join(root, "yarn.lock"));
+    const npm = io.existsSync(join(root, "package-lock.json"));
+    const present = [pnpm, yarn, npm].filter(Boolean).length;
+    if (present > 1)
+        return "unknown";
+    if (pnpm)
+        return "pnpm";
+    if (yarn)
+        return "yarn";
+    if (npm)
+        return "npm";
+    return "unknown";
+}
+export function okResult(kind, patch) {
+    return { kind, status: "ok", candidates: [], evidence: [], fixes: [], ...patch };
+}
+export function createFileFix(path, content) {
+    return { kind: "create", path, before: undefined, after: content };
+}

package/dist/project/anchors/moeicons-config.d.ts

@@ -0,0 +1,21 @@
+import type { IconCatalog } from "../../catalog/catalog.js";
+import type { AnchorResult } from "./types.js";
+import type { DetectorIo } from "./helpers.js";
+import type { Target } from "../../commands/parser.js";
+/** Supported target for a freshly created config from the manifest adapter. */
+export declare function targetFromAdapter(adapter: string | undefined): Target;
+export interface ConfigAnchorOptions {
+    readonly root: string;
+    readonly sourceCatalog?: IconCatalog | undefined;
+    readonly io?: DetectorIo;
+    readonly adapter?: string;
+    /** true when only assets are consumed and app entry is not required. */
+    readonly assetsOnly?: boolean;
+    readonly ambiguous?: boolean;
+}
+/**
+ * Moeicons config anchor (E2E-B2). Never writes. If the config is missing and
+ * this is a writable project it builds a create-file plan using the canonical
+ * renderer; an existing invalid file is reported and never overwritten.
+ */
+export declare function inspectMoeiconsConfig(options: ConfigAnchorOptions): AnchorResult;

package/dist/project/anchors/moeicons-config.js

@@ -0,0 +1,83 @@
+import { join } from "node:path";
+import { findConfigFile, readMoeiconsConfig } from "../config.js";
+import { renderMoeiconsConfigJsonc } from "../config.js";
+/** Supported target for a freshly created config from the manifest adapter. */
+export function targetFromAdapter(adapter) {
+    if (adapter === "vite-vue" || adapter === "nuxt")
+        return "vue";
+    if (adapter === "vite-react" || adapter === "next-app" || adapter === "next-pages")
+        return "react";
+    if (adapter === "vanilla")
+        return "vanilla";
+    return "react";
+}
+/**
+ * Moeicons config anchor (E2E-B2). Never writes. If the config is missing and
+ * this is a writable project it builds a create-file plan using the canonical
+ * renderer; an existing invalid file is reported and never overwritten.
+ */
+export function inspectMoeiconsConfig(options) {
+    const configPath = findConfigFile(options.root);
+    if (!configPath) {
+        if (options.ambiguous && !options.adapter && !options.assetsOnly) {
+            return { kind: "config", status: "ambiguous", candidates: [], evidence: ["select a target with --target before initializing this project"], fixes: [] };
+        }
+        const target = options.assetsOnly ? "assets" : targetFromAdapter(options.adapter);
+        const content = renderMoeiconsConfigJsonc({ target });
+        return {
+            kind: "config",
+            status: "missing",
+            path: join(options.root, "moeicons.config.jsonc"),
+            candidates: [],
+            evidence: ["no moeicons config found; a create plan is available"],
+            fixes: [
+                {
+                    kind: "create",
+                    path: "moeicons.config.jsonc",
+                    before: undefined,
+                    after: content,
+                },
+            ],
+        };
+    }
+    const loaded = readMoeiconsConfig(options.root, options.sourceCatalog);
+    if (loaded.kind === "ok") {
+        return {
+            kind: "config",
+            status: "ok",
+            path: configPath,
+            candidates: [],
+            evidence: [`config schema v${loaded.config.schemaVersion} valid`, ...loaded.warnings],
+            fixes: [],
+        };
+    }
+    if (loaded.kind === "unsupported") {
+        return {
+            kind: "config",
+            status: "unsupported",
+            path: configPath,
+            candidates: [],
+            evidence: [`config schema version ${loaded.version} is not supported`],
+            fixes: [],
+        };
+    }
+    if (loaded.kind === "invalid") {
+        return {
+            kind: "config",
+            status: "invalid",
+            path: configPath,
+            candidates: [],
+            evidence: [loaded.message],
+            fixes: [],
+        };
+    }
+    // loaded.kind === "missing" is impossible because findConfigFile found one.
+    return {
+        kind: "config",
+        status: "invalid",
+        path: configPath,
+        candidates: [],
+        evidence: ["config exists but could not be loaded"],
+        fixes: [],
+    };
+}

package/dist/project/anchors/parse.d.ts

@@ -0,0 +1,14 @@
+import type { File } from "@babel/types";
+/**
+ * Parse TS/TSX/JS/JSX/Vue-main source with @babel/parser. Returns `undefined`
+ * when the file cannot be parsed (syntax error / unknown syntax), never throws.
+ * Recorded before adding as runtime dep: @babel/parser 7.29.8, MIT license,
+ * ~1.9 MB unpacked, `npm audit --omit=dev` clean.
+ */
+export declare function parseSource(source: string, filePath: string): {
+    readonly ok: true;
+    readonly ast: File;
+} | {
+    readonly ok: false;
+    readonly error: string;
+};

package/dist/project/anchors/parse.js

@@ -0,0 +1,36 @@
+import { parse } from "@babel/parser";
+/**
+ * Parse TS/TSX/JS/JSX/Vue-main source with @babel/parser. Returns `undefined`
+ * when the file cannot be parsed (syntax error / unknown syntax), never throws.
+ * Recorded before adding as runtime dep: @babel/parser 7.29.8, MIT license,
+ * ~1.9 MB unpacked, `npm audit --omit=dev` clean.
+ */
+export function parseSource(source, filePath) {
+    const isTs = /\.tsx?$/i.test(filePath);
+    const plugins = [];
+    if (isTs) {
+        plugins.push("typescript");
+        if (/\.tsx$/i.test(filePath))
+            plugins.push("jsx");
+    }
+    else {
+        plugins.push("jsx");
+    }
+    plugins.push("decorators-legacy", "importAttributes", "explicitResourceManagement", "classProperties", "classPrivateProperties", "classPrivateMethods", "topLevelAwait");
+    try {
+        const ast = parse(source, {
+            sourceType: "module",
+            allowReturnOutsideFunction: true,
+            allowImportExportEverywhere: true,
+            errorRecovery: false,
+            plugins,
+        });
+        return { ok: true, ast };
+    }
+    catch (error) {
+        return {
+            ok: false,
+            error: error instanceof Error ? error.message : String(error),
+        };
+    }
+}

package/dist/project/anchors/project-manifest.d.ts

@@ -0,0 +1,19 @@
+import type { AnchorResult } from "./types.js";
+import { type DetectorIo } from "./helpers.js";
+export interface AdapterEvidence {
+    readonly adapter: string | undefined;
+    readonly candidateAdapters: readonly string[];
+    readonly framework: "react" | "vue" | "vanilla" | "unknown";
+}
+/** Detect adapter/framework from package.json deps + key config files. */
+export declare function detectAdapter(io: DetectorIo, root: string, pkg: Record<string, unknown>): AdapterEvidence;
+export interface ManifestAnchorOptions {
+    readonly cwd: string;
+    readonly io: DetectorIo;
+}
+/**
+ * Project manifest anchor (E2E-B2). Never writes. Locates the nearest
+ * package.json, classifies package manager + workspace membership + adapter,
+ * and returns candidates when the layout is ambiguous.
+ */
+export declare function inspectProjectManifest(options: ManifestAnchorOptions): AnchorResult;

package/dist/project/anchors/project-manifest.js

@@ -0,0 +1,109 @@
+import { join, relative } from "node:path";
+import { findPackageJsonDir, detectPackageManager, readJsonSafe, isRecord, } from "./helpers.js";
+/** Detect adapter/framework from package.json deps + key config files. */
+export function detectAdapter(io, root, pkg) {
+    const deps = new Set([
+        ...Object.keys(isRecord(pkg.dependencies) ? pkg.dependencies : {}),
+        ...Object.keys(isRecord(pkg.devDependencies) ? pkg.devDependencies : {}),
+    ]);
+    const has = (name) => deps.has(name);
+    const candidates = [];
+    const hasNext = has("next");
+    const hasNuxt = has("nuxt");
+    const hasVue = has("vue");
+    const hasReact = has("react") || has("react-dom");
+    const hasVite = has("vite") || has("@vitejs/plugin-react") || has("@vitejs/plugin-vue");
+    if (hasNext) {
+        const app = io.existsSync(join(root, "app")) || io.existsSync(join(root, "src", "app"));
+        candidates.push(app ? "next-app" : "next-pages");
+    }
+    if (hasNuxt) {
+        candidates.push("nuxt");
+    }
+    if (hasVite && hasVue)
+        candidates.push("vite-vue");
+    if (hasVite && hasReact)
+        candidates.push("vite-react");
+    if (hasVue && !hasVite && !hasNuxt)
+        candidates.push("nuxt"); // heuristic via plugin file below
+    if (hasReact && !hasVite && !hasNext)
+        candidates.push("vite-react");
+    if (candidates.length === 0) {
+        const hasVanillaEntry = io.existsSync(join(root, "src", "main.ts")) ||
+            io.existsSync(join(root, "src", "main.js")) ||
+            io.existsSync(join(root, "main.ts")) ||
+            io.existsSync(join(root, "main.js"));
+        if (hasVanillaEntry) {
+            candidates.push("vanilla");
+            return { adapter: "vanilla", candidateAdapters: ["vanilla"], framework: "vanilla" };
+        }
+        return { adapter: undefined, candidateAdapters: [], framework: "unknown" };
+    }
+    const unique = [...new Set(candidates)];
+    const framework = hasVue
+        ? "vue"
+        : hasReact
+            ? "react"
+            : "unknown";
+    return {
+        adapter: unique.length === 1 ? unique[0] : undefined,
+        candidateAdapters: unique,
+        framework: unique.length === 1 ? framework : "unknown",
+    };
+}
+/**
+ * Project manifest anchor (E2E-B2). Never writes. Locates the nearest
+ * package.json, classifies package manager + workspace membership + adapter,
+ * and returns candidates when the layout is ambiguous.
+ */
+export function inspectProjectManifest(options) {
+    const { io } = options;
+    const root = findPackageJsonDir(io, options.cwd);
+    if (!root) {
+        return {
+            kind: "manifest",
+            status: "missing",
+            candidates: [],
+            evidence: ["no package.json found in cwd or parents"],
+            fixes: [],
+        };
+    }
+    const pkg = readJsonSafe(io, join(root, "package.json"));
+    if (!pkg) {
+        return {
+            kind: "manifest",
+            status: "invalid",
+            path: join(root, "package.json"),
+            candidates: [],
+            evidence: ["package.json exists but is not valid JSON"],
+            fixes: [],
+        };
+    }
+    const packageManager = detectPackageManager(io, root);
+    const workspace = isRecord(pkg.workspaces)
+        ? []
+        : typeof pkg.workspaces === "string"
+            ? [pkg.workspaces]
+            : Array.isArray(pkg.workspaces)
+                ? pkg.workspaces.filter((w) => typeof w === "string")
+                : [];
+    const memberHint = workspace.length ? ` (workspace root, members: ${workspace.join(", ")})` : "";
+    const adapterInfo = detectAdapter(io, root, pkg);
+    const evidence = [
+        `package.json: ${relative(options.cwd, join(root, "package.json")) || "package.json"}`,
+        `packageManager: ${packageManager}${memberHint}`,
+        adapterInfo.adapter
+            ? `adapter: ${adapterInfo.adapter}`
+            : adapterInfo.candidateAdapters.length > 0
+                ? `adapter ambiguous: ${adapterInfo.candidateAdapters.join(", ")}`
+                : "adapter: unknown",
+    ];
+    return {
+        kind: "manifest",
+        status: packageManager === "unknown" ? "ambiguous" : "ok",
+        path: join(root, "package.json"),
+        candidates: [],
+        evidence,
+        fixes: [],
+    };
+}

package/dist/project/anchors/style.d.ts

@@ -0,0 +1,12 @@
+import type { AnchorResult } from "./types.js";
+import type { DetectorIo } from "./helpers.js";
+export interface StyleAnchorOptions {
+    readonly root: string;
+    readonly io: DetectorIo;
+    /** Confirmed style path stored in config (preferred source). */
+    readonly confirmedStyle?: string;
+    /** true when the target is assets-only. */
+    readonly assetsOnly?: boolean;
+}
+export declare function findCssCandidates(io: DetectorIo, root: string): readonly string[];
+export declare function inspectStyleAnchor(options: StyleAnchorOptions): AnchorResult;

package/dist/project/anchors/style.js

@@ -0,0 +1,87 @@
+import { join } from "node:path";
+/**
+ * Styling anchor (E2E-B4). This anchor is OPTIONAL: absence of Tailwind or CSS
+ * is a warning/`missing` result, never a hard failure. The detector is
+ * read-only: it resolves the CSS entry, checks whether moeicons styles are
+ * imported, and reports Tailwind status as evidence. It only offers a safe fix
+ * only when a real generated stylesheet exists. Core icon dimensions are
+ * expressed as element attributes, so no stylesheet is required by default.
+ */
+const CSS_CANDIDATES = [
+    "src/index.css",
+    "src/style.css",
+    "src/styles.css",
+    "app/globals.css",
+    "src/app/globals.css",
+];
+export function findCssCandidates(io, root) {
+    return CSS_CANDIDATES.filter((rel) => io.existsSync(join(root, rel)));
+}
+function cssImportsMoeicons(source) {
+    // CSS entry may import a stylesheet that carries the moeicons class base, or a
+    // JS/TS entry imports "moeicons/styles.css". Keep both cheap checks.
+    return /moeicons/.test(source);
+}
+export function inspectStyleAnchor(options) {
+    const { io, root, assetsOnly } = options;
+    if (assetsOnly) {
+        return {
+            kind: "style",
+            status: "not-required",
+            candidates: [],
+            evidence: ["assets-only target requires no styling integration"],
+            fixes: [],
+        };
+    }
+    const candidates = options.confirmedStyle && io.existsSync(join(root, options.confirmedStyle))
+        ? [options.confirmedStyle]
+        : findCssCandidates(io, root);
+    if (candidates.length === 0) {
+        return {
+            kind: "style",
+            status: "missing",
+            candidates: CSS_CANDIDATES,
+            evidence: ["no CSS entry found; styling integration is optional (warning only)"],
+            fixes: [],
+        };
+    }
+    if (candidates.length > 1) {
+        return {
+            kind: "style",
+            status: "ambiguous",
+            candidates,
+            evidence: [`multiple CSS entry candidates: ${candidates.join(", ")}`],
+            fixes: [],
+        };
+    }
+    const rel = candidates[0] ?? "";
+    const full = join(root, rel);
+    let source = "";
+    try {
+        source = io.readFileSync(full);
+    }
+    catch {
+        source = "";
+    }
+    if (cssImportsMoeicons(source)) {
+        return {
+            kind: "style",
+            status: "ok",
+            path: full,
+            candidates: [],
+            evidence: [`moeicons styles referenced in ${rel}`],
+            fixes: [],
+        };
+    }
+    return {
+        kind: "style",
+        status: "missing",
+        path: full,
+        candidates: [],
+        evidence: [
+            `CSS entry: ${rel}`,
+            "no moeicons stylesheet is generated; add optional project styles manually if needed",
+        ],
+        fixes: [],
+    };
+}