koishi-plugin-emojiluna-plus 0.0.1

package/lib/image/imageProcessor.js

@@ -0,0 +1,243 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.detectImageFormat = detectImageFormat;
+exports.getImageMetadata = getImageMetadata;
+exports.sampleFrameIndices = sampleFrameIndices;
+exports.extractSampledFrames = extractSampledFrames;
+exports.extractFrameRgba = extractFrameRgba;
+exports.resizeFrameToGrayscale = resizeFrameToGrayscale;
+const core_1 = require("@jimp/core");
+const jimp_1 = require("jimp");
+const gifuct_js_1 = require("gifuct-js");
+const Jimp = (0, core_1.createJimp)({
+    formats: [...jimp_1.defaultFormats],
+    plugins: jimp_1.defaultPlugins
+});
+const clampFrameIndex = (index, frameCount) => {
+    if (frameCount <= 1)
+        return 0;
+    return Math.max(0, Math.min(frameCount - 1, index));
+};
+const toArrayBuffer = (buffer) => {
+    return buffer.buffer.slice(buffer.byteOffset, buffer.byteOffset + buffer.byteLength);
+};
+function detectImageFormat(buffer) {
+    const header = buffer.subarray(0, 12);
+    if (header[0] === 0xff && header[1] === 0xd8)
+        return 'jpeg';
+    if (header[0] === 0x89 &&
+        header[1] === 0x50 &&
+        header[2] === 0x4e &&
+        header[3] === 0x47)
+        return 'png';
+    if (header[0] === 0x47 && header[1] === 0x49 && header[2] === 0x46)
+        return 'gif';
+    if (header[0] === 0x52 &&
+        header[1] === 0x49 &&
+        header[2] === 0x46 &&
+        header[8] === 0x57 &&
+        header[9] === 0x45 &&
+        header[10] === 0x42 &&
+        header[11] === 0x50)
+        return 'webp';
+    if (header[0] === 0x42 && header[1] === 0x4d)
+        return 'bmp';
+    return 'unknown';
+}
+async function getImageMetadata(buffer) {
+    const format = detectImageFormat(buffer);
+    if (format === 'gif') {
+        const gif = (0, gifuct_js_1.parseGIF)(toArrayBuffer(buffer));
+        const frames = (0, gifuct_js_1.decompressFrames)(gif, false);
+        return {
+            format,
+            width: gif.lsd?.width ?? 0,
+            height: gif.lsd?.height ?? 0,
+            frameCount: frames.length || 1
+        };
+    }
+    if (format === 'webp') {
+        const frame = await decodeWebpFrame(buffer);
+        return {
+            format,
+            width: frame.width,
+            height: frame.height,
+            frameCount: 1
+        };
+    }
+    const image = await Jimp.read(buffer);
+    return {
+        format,
+        width: image.bitmap.width,
+        height: image.bitmap.height,
+        frameCount: 1
+    };
+}
+function sampleFrameIndices(frameCount, sampleCount) {
+    const safeFrameCount = Math.max(1, frameCount);
+    const safeSampleCount = Math.max(1, Math.min(sampleCount, safeFrameCount));
+    if (safeFrameCount === 1)
+        return [0];
+    if (safeSampleCount === 1)
+        return [Math.floor(safeFrameCount / 2)];
+    const indices = new Set();
+    for (let i = 0; i < safeSampleCount; i++) {
+        const ratio = i / (safeSampleCount - 1);
+        const index = Math.round((safeFrameCount - 1) * ratio);
+        indices.add(index);
+    }
+    return Array.from(indices).sort((a, b) => a - b);
+}
+async function extractSampledFrames(buffer, sampleCount, outputFormat = 'png') {
+    const sourceMetadata = await getImageMetadata(buffer);
+    const indices = sampleFrameIndices(sourceMetadata.frameCount, sampleCount);
+    const decodedFrames = await decodeFrames(buffer, sourceMetadata, indices);
+    const normalizedOutputFormat = sourceMetadata.format === 'gif' ? 'png' : outputFormat;
+    const frames = await Promise.all(decodedFrames.map((frame) => encodeFrame(frame, normalizedOutputFormat)));
+    const firstFrame = decodedFrames[0];
+    const metadata = firstFrame
+        ? {
+            format: normalizedOutputFormat,
+            width: firstFrame.width,
+            height: firstFrame.height,
+            frameCount: 1
+        }
+        : {
+            format: normalizedOutputFormat,
+            width: sourceMetadata.width,
+            height: sourceMetadata.height,
+            frameCount: 1
+        };
+    return { frames, metadata };
+}
+async function extractFrameRgba(buffer, metadata, frameIndex) {
+    const index = clampFrameIndex(frameIndex, metadata.frameCount);
+    const [frame] = await decodeFrames(buffer, metadata, [index]);
+    if (!frame) {
+        throw new Error('Unable to decode frame');
+    }
+    return frame;
+}
+async function resizeFrameToGrayscale(frame, targetWidth, targetHeight) {
+    return resizeToGrayscale(frame.data, frame.width, frame.height, targetWidth, targetHeight);
+}
+async function decodeFrames(buffer, metadata, frameIndices) {
+    if (metadata.frameCount <= 1 || frameIndices.length === 0) {
+        const frame = await decodeStaticFrame(buffer);
+        return [frame];
+    }
+    if (metadata.format === 'gif') {
+        return decodeGifFrames(buffer, frameIndices);
+    }
+    if (metadata.format === 'webp') {
+        const frame = await decodeWebpFrame(buffer);
+        return [frame];
+    }
+    const frame = await decodeStaticFrame(buffer);
+    return [frame];
+}
+async function decodeStaticFrame(buffer) {
+    const image = await Jimp.read(buffer);
+    return {
+        width: image.bitmap.width,
+        height: image.bitmap.height,
+        data: new Uint8Array(image.bitmap.data)
+    };
+}
+function decodeGifFrames(buffer, frameIndices) {
+    const gif = (0, gifuct_js_1.parseGIF)(toArrayBuffer(buffer));
+    const frames = (0, gifuct_js_1.decompressFrames)(gif, true);
+    const width = gif.lsd?.width ?? frames[0]?.dims?.width ?? 0;
+    const height = gif.lsd?.height ?? frames[0]?.dims?.height ?? 0;
+    const target = new Set(frameIndices);
+    const output = [];
+    let canvas = new Uint8Array(width * height * 4);
+    let restoreCanvas = null;
+    let previousDisposal = 0;
+    let previousDims = null;
+    frames.forEach((frame, index) => {
+        if (index > 0) {
+            if (previousDisposal === 2 && previousDims) {
+                clearRect(canvas, width, previousDims);
+            }
+            else if (previousDisposal === 3 && restoreCanvas) {
+                canvas = new Uint8Array(restoreCanvas);
+            }
+        }
+        restoreCanvas = frame.disposalType === 3 ? new Uint8Array(canvas) : null;
+        drawPatch(canvas, width, new Uint8Array(frame.patch), frame.dims);
+        if (target.has(index)) {
+            output.push({
+                width,
+                height,
+                data: new Uint8Array(canvas)
+            });
+        }
+        previousDisposal = frame.disposalType ?? 0;
+        previousDims = frame.dims ?? null;
+    });
+    return output;
+}
+function clearRect(canvas, width, dims) {
+    const { left, top, width: rectWidth, height: rectHeight } = dims;
+    for (let y = 0; y < rectHeight; y++) {
+        const rowStart = (top + y) * width + left;
+        const rowEnd = rowStart + rectWidth;
+        for (let x = rowStart; x < rowEnd; x++) {
+            const offset = x * 4;
+            canvas[offset] = 0;
+            canvas[offset + 1] = 0;
+            canvas[offset + 2] = 0;
+            canvas[offset + 3] = 0;
+        }
+    }
+}
+function drawPatch(canvas, width, patch, dims) {
+    const { left, top, width: patchWidth, height: patchHeight } = dims;
+    for (let y = 0; y < patchHeight; y++) {
+        for (let x = 0; x < patchWidth; x++) {
+            const patchOffset = (y * patchWidth + x) * 4;
+            const alpha = patch[patchOffset + 3];
+            if (alpha === 0)
+                continue;
+            const destOffset = ((top + y) * width + (left + x)) * 4;
+            canvas[destOffset] = patch[patchOffset];
+            canvas[destOffset + 1] = patch[patchOffset + 1];
+            canvas[destOffset + 2] = patch[patchOffset + 2];
+            canvas[destOffset + 3] = alpha;
+        }
+    }
+}
+async function decodeWebpFrame(buffer) {
+    const image = await Jimp.read(buffer);
+    return {
+        width: image.bitmap.width,
+        height: image.bitmap.height,
+        data: new Uint8Array(image.bitmap.data)
+    };
+}
+async function encodeFrame(frame, format) {
+    const image = new Jimp({
+        data: Buffer.from(frame.data),
+        width: frame.width,
+        height: frame.height
+    });
+    if (format === 'jpeg') {
+        return await image.getBuffer('image/jpeg', { quality: 70 });
+    }
+    return await image.getBuffer('image/png');
+}
+async function resizeToGrayscale(pixels, width, height, targetWidth, targetHeight) {
+    const base = new Jimp({
+        data: Buffer.from(pixels),
+        width,
+        height
+    });
+    const image = base.resize({ w: targetWidth, h: targetHeight }).greyscale();
+    const resized = image.bitmap.data;
+    const grayscale = new Uint8Array(targetWidth * targetHeight);
+    for (let i = 0, j = 0; i < resized.length; i += 4, j++) {
+        grayscale[j] = resized[i];
+    }
+    return grayscale;
+}

package/lib/image/index.d.ts

@@ -0,0 +1 @@
+export * from './imageProcessor';

package/lib/image/index.js

@@ -0,0 +1,17 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./imageProcessor"), exports);

package/lib/index.d.ts

@@ -0,0 +1,57 @@
+import { Context } from 'koishi';
+import { Config } from './config';
+import { EmojiLunaService } from './services';
+import { Category, EmojiItem, EmojiSearchOptions } from './types';
+export declare function apply(ctx: Context, config: Config): void;
+export * from './config';
+export * from './types';
+export declare const inject: string[];
+declare module 'koishi' {
+    interface Context {
+        emojiluna: EmojiLunaService;
+    }
+    interface Events {
+        'emojiluna/emoji-added': (emoji: EmojiItem) => void;
+        'emojiluna/emoji-deleted': (id: string) => void;
+        'emojiluna/emoji-updated': (emoji: EmojiItem) => void;
+        'emojiluna/category-added': (category: Category) => void;
+        'emojiluna/category-deleted': (id: string) => void;
+    }
+    interface Tables {
+        emojiluna_emojis: {
+            id: string;
+            name: string;
+            category: string;
+            path: string;
+            size: number;
+            mime_type: string;
+            created_at: Date;
+            tags: string;
+            image_hash: string;
+            description: string;
+        };
+        emojiluna_categories: {
+            id: string;
+            name: string;
+            description: string;
+            emoji_count: number;
+            created_at: Date;
+        };
+    }
+}
+declare module '@koishijs/console' {
+    interface Events {
+        'emojiluna/getAiTaskStats': () => Promise<{
+            pending: number;
+            processing: number;
+            succeeded: number;
+            failed: number;
+            paused: boolean;
+        }>;
+        'emojiluna/getEmojiCount': (options?: EmojiSearchOptions) => Promise<number>;
+        'emojiluna/getFailedAiEmojiIds': () => Promise<string[]>;
+        'emojiluna/reanalyzeBatch': (ids: string[]) => Promise<number>;
+        'emojiluna/setAiPaused': (paused: boolean) => void;
+        'emojiluna/retryFailedTasks': () => Promise<number>;
+    }
+}

package/lib/index.js

@@ -0,0 +1,40 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.inject = void 0;
+exports.apply = apply;
+const services_1 = require("./services");
+const adapters_1 = require("./adapters");
+const collectors_1 = require("./collectors");
+const schema_1 = require("koishi-plugin-chatluna/utils/schema");
+function apply(ctx, config) {
+    ctx.plugin(services_1.EmojiLunaService, config);
+    ctx.on('ready', () => {
+        ctx.inject(['emojiluna'], (ctx) => {
+            const emojiluna = ctx.emojiluna;
+            const autoCollector = new collectors_1.AutoCollector(ctx, config, emojiluna.debug);
+            emojiluna.autoCollector = autoCollector;
+            (0, adapters_1.applyCommands)(ctx, config, autoCollector);
+            (0, adapters_1.applyBackend)(ctx, config);
+            ctx.effect(() => () => autoCollector.dispose());
+            autoCollector.start();
+        });
+        (0, schema_1.modelSchema)(ctx);
+    });
+}
+__exportStar(require("./config"), exports);
+__exportStar(require("./types"), exports);
+exports.inject = ['chatluna', 'database'];

package/lib/services/aiAnalyzer.d.ts

@@ -0,0 +1,24 @@
+import { Context } from 'koishi';
+import { Config } from '../config';
+import { DebugLogger } from '../debug';
+import { AIAnalyzeResult, AICategorizeResult, AIImageFilterResult } from '../types';
+import { ChatLunaChatModel } from 'koishi-plugin-chatluna/llm-core/platform/model';
+import { ComputedRef } from 'koishi-plugin-chatluna';
+export declare class AIAnalyzer {
+    private ctx;
+    private config;
+    private debug;
+    private static readonly AI_FRAME_SAMPLES;
+    private _model;
+    constructor(ctx: Context, config: Config, debug: DebugLogger);
+    get model(): ComputedRef<ChatLunaChatModel>;
+    get hasModel(): boolean;
+    initialize(): Promise<void>;
+    private parseAIResult;
+    private callModel;
+    private invokeAI;
+    private buildAIImages;
+    categorize(imageBase64: string): Promise<AICategorizeResult | null>;
+    analyze(imageBase64: string): Promise<AIAnalyzeResult | null>;
+    filterImageType(imageBase64: string): Promise<AIImageFilterResult | null>;
+}

package/lib/services/aiAnalyzer.js

@@ -0,0 +1,162 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AIAnalyzer = void 0;
+const utils_1 = require("../utils");
+const image_1 = require("../image");
+const messages_1 = require("@langchain/core/messages");
+const string_1 = require("koishi-plugin-chatluna/utils/string");
+const count_tokens_1 = require("koishi-plugin-chatluna/llm-core/utils/count_tokens");
+class AIAnalyzer {
+    ctx;
+    config;
+    debug;
+    static AI_FRAME_SAMPLES = 3;
+    _model = null;
+    constructor(ctx, config, debug) {
+        this.ctx = ctx;
+        this.config = config;
+        this.debug = debug;
+    }
+    get model() {
+        return this._model;
+    }
+    get hasModel() {
+        return Boolean(this._model?.value);
+    }
+    async initialize() {
+        const needsModel = this.config.autoCategorize ||
+            this.config.autoAnalyze ||
+            this.config.enableImageTypeFilter;
+        if (!needsModel) {
+            this.debug.log('ai', '未启用任何 AI 功能，跳过模型加载');
+            return;
+        }
+        if (!this.config.model) {
+            this.ctx.logger.warn('AI 功能已启用但未选择模型，请在配置项「使用的AI模型」中设置 model');
+            return;
+        }
+        try {
+            const [platform] = (0, count_tokens_1.parseRawModelName)(this.config.model);
+            await this.ctx.chatluna.awaitLoadPlatform(platform);
+            this._model = await this.ctx.chatluna.createChatModel(this.config.model);
+            this.ctx.logger.success('AI模型加载成功');
+            this.debug.log('ai', `模型加载成功: ${this.config.model}`);
+        }
+        catch (error) {
+            this._model = null;
+            this.ctx.logger.error(`AI模型加载失败: ${error.message}`);
+        }
+    }
+    parseAIResult(result) {
+        for (const extractor of utils_1.extractors) {
+            const extracted = extractor(result);
+            const parsed = (0, utils_1.tryParse)(extracted);
+            if (parsed) {
+                this.debug.log('ai', `解析成功 (${result.length} 字符)`, parsed);
+                return parsed;
+            }
+        }
+        this.ctx.logger.error(`AI结果解析失败: ${result}`);
+        return null;
+    }
+    async callModel(prompt, imageBase64) {
+        const images = await this.buildAIImages(imageBase64);
+        this.debug.log('ai', `发起请求，图片帧 ${images.length} 张`, {
+            model: this.config.model,
+            promptLength: prompt.length,
+        });
+        const result = await (0, utils_1.withTimeout)(this._model.value.invoke([
+            new messages_1.SystemMessage(prompt),
+            new messages_1.HumanMessage({
+                content: [
+                    { type: 'text', text: 'Please analyze this emoji' },
+                    ...images.map((image) => ({
+                        type: 'image_url',
+                        image_url: {
+                            url: `data:${image.mimeType};base64,${image.data}`,
+                            detail: 'low',
+                        },
+                    })),
+                ],
+            }),
+        ]), this.config.AIRequestTimeout, 'AI 请求');
+        return (0, string_1.getMessageContent)(result.content);
+    }
+    async invokeAI(prompt, imageBase64) {
+        if (!this._model?.value)
+            return null;
+        return this.parseAIResult(await this.callModel(prompt, imageBase64));
+    }
+    async buildAIImages(imageBase64) {
+        try {
+            const buffer = Buffer.from(imageBase64, 'base64');
+            const metadata = await (0, image_1.getImageMetadata)(buffer);
+            if (metadata.frameCount <= 1) {
+                return [
+                    { data: imageBase64, mimeType: `image/${metadata.format}` }
+                ];
+            }
+            const { frames, metadata: framesMetadata } = await (0, image_1.extractSampledFrames)(buffer, AIAnalyzer.AI_FRAME_SAMPLES, metadata.format);
+            if (frames.length === 0) {
+                return [
+                    { data: imageBase64, mimeType: `image/${metadata.format}` }
+                ];
+            }
+            return frames.map((frame) => ({
+                data: frame.toString('base64'),
+                mimeType: `image/${framesMetadata.format}`
+            }));
+        }
+        catch (error) {
+            this.ctx.logger.warn(`AI image preparation failed: ${error.message}`);
+            return [{ data: imageBase64, mimeType: 'image/png' }];
+        }
+    }
+    async categorize(imageBase64) {
+        if (!this._model?.value || !this.config.autoCategorize)
+            return null;
+        try {
+            const prompt = this.config.categorizePrompt.replaceAll('{categories}', this.config.categories.join(', '));
+            return await this.invokeAI(prompt, imageBase64);
+        }
+        catch (error) {
+            this.ctx.logger.error('AI categorization failed:', error);
+            return null;
+        }
+    }
+    async analyze(imageBase64) {
+        if (!this._model?.value || !this.config.autoAnalyze)
+            return null;
+        try {
+            const prompt = this.config.analyzePrompt.replaceAll('{categories}', this.config.categories.join(', '));
+            return await this.invokeAI(prompt, imageBase64);
+        }
+        catch (error) {
+            this.ctx.logger.error('AI analysis failed:', error);
+            return null;
+        }
+    }
+    async filterImageType(imageBase64) {
+        if (!this._model?.value || !this.config.enableImageTypeFilter) {
+            return null;
+        }
+        try {
+            const parsedResult = await this.invokeAI(this.config.imageFilterPrompt, imageBase64);
+            if (!parsedResult)
+                return null;
+            const isAcceptable = parsedResult.isUseful &&
+                this.config.acceptedImageTypes.includes(parsedResult.imageType);
+            return {
+                imageType: parsedResult.imageType,
+                isAcceptable,
+                confidence: parsedResult.confidence,
+                reason: parsedResult.reason
+            };
+        }
+        catch (error) {
+            this.ctx.logger.error('AI图片类型过滤失败:', error);
+            return null;
+        }
+    }
+}
+exports.AIAnalyzer = AIAnalyzer;

package/lib/services/emojiluna.d.ts

@@ -0,0 +1,102 @@
+import { Context, Service } from 'koishi';
+import { Config } from '../config';
+import { UploadManager } from '../storage';
+import { AIAnalyzer } from './aiAnalyzer';
+import { AIAnalyzeResult, AICategorizeResult, AIImageFilterResult, AITaskDetail, Category, CategorySearchOptions, EmojiAddOptions, EmojiItem, EmojiSearchOptions, FolderImportOptions, FolderImportResult, FolderScanResult, PaginatedResult, TagInfo, TagSearchOptions } from '../types';
+import { DebugLogger } from '../debug';
+import type { AutoCollector } from '../collectors/autoCollector';
+export declare class EmojiLunaService extends Service {
+    config: Config;
+    private _emojiStorage;
+    private _categories;
+    private _isInitialized;
+    private _readyPromise;
+    private _readyResolve;
+    private _isDisposed;
+    private _uploadManager;
+    private _aiAnalyzer;
+    private _byName;
+    private _byTag;
+    private _byCategory;
+    private _storageDir;
+    private _uploadToken;
+    readonly debug: DebugLogger;
+    autoCollector: AutoCollector | null;
+    constructor(ctx: Context, config: Config);
+    get ready(): Promise<void>;
+    get uploadManager(): UploadManager;
+    get storageDir(): string;
+    get aiAnalyzer(): AIAnalyzer;
+    get uploadToken(): string;
+    private initializeStorage;
+    get isInitialized(): boolean;
+    readEmojiBuffer(emoji: EmojiItem): Promise<Buffer | null>;
+    private indexEmoji;
+    private unindexEmoji;
+    private reindexEmoji;
+    categorizeEmoji(imageBase64: string): Promise<AICategorizeResult | null>;
+    analyzeEmoji(imageBase64: string): Promise<AIAnalyzeResult | null>;
+    filterImageByType(imageBase64: string): Promise<AIImageFilterResult | null>;
+    private assertActive;
+    addEmoji(options: EmojiAddOptions, source: Buffer | {
+        path: string;
+    }, aiAnalysis?: boolean): Promise<EmojiItem>;
+    private buildEmojiRecord;
+    private persistEmoji;
+    addEmojis(emojis: {
+        options: EmojiAddOptions;
+        buffer: Buffer;
+    }[], aiAnalysis: boolean): Promise<EmojiItem[]>;
+    getEmojiByName(name: string): Promise<EmojiItem | null>;
+    getEmojisByName(name: string): Promise<EmojiItem[]>;
+    getEmojiById(id: string): Promise<EmojiItem | null>;
+    private filterEmojis;
+    getEmojiList(options?: EmojiSearchOptions): Promise<EmojiItem[]>;
+    getEmojiPage(options?: EmojiSearchOptions): Promise<PaginatedResult<EmojiItem>>;
+    searchEmoji(keyword: string): Promise<EmojiItem[]>;
+    deleteEmoji(id: string): Promise<boolean>;
+    deleteAllEmojis(): Promise<boolean>;
+    updateEmojiInfo(id: string, updates: Partial<Pick<EmojiItem, 'name' | 'category' | 'tags' | 'description'>>): Promise<boolean>;
+    updateEmojiName(id: string, name: string): Promise<boolean>;
+    updateEmojiTags(id: string, tags: string[]): Promise<boolean>;
+    updateEmojiCategory(id: string, category: string): Promise<boolean>;
+    addCategory(name: string, description?: string): Promise<Category>;
+    getCategories(): Promise<Category[]>;
+    getCategoriesPage(options?: CategorySearchOptions): Promise<PaginatedResult<Category>>;
+    getCategoryByName(name: string): Promise<Category | null>;
+    deleteCategory(id: string, deleteEmojis?: boolean): Promise<boolean>;
+    cleanupEmptyCategories(): Promise<number>;
+    private buildTagUsageMap;
+    getAllTags(): Promise<string[]>;
+    getTagsPage(options?: TagSearchOptions): Promise<PaginatedResult<TagInfo>>;
+    cleanupEmptyTags(): Promise<number>;
+    categorizeExistingEmojis(): Promise<{
+        success: number;
+        failed: number;
+    }>;
+    private static readonly SUPPORTED_EXTENSIONS;
+    scanFolder(folderPath: string): Promise<FolderScanResult>;
+    private scanFolderRecursive;
+    private emojiNameExists;
+    importFromFolder(options: FolderImportOptions): Promise<FolderImportResult>;
+    private updateCategoryEmojiCount;
+    private loadEmojis;
+    private loadCategories;
+    getEmojiCount(): number;
+    getCategoryCount(): number;
+    getAiTaskStats(): Promise<{
+        pending: number;
+        processing: number;
+        succeeded: number;
+        failed: number;
+        paused: boolean;
+    }>;
+    getFailedAiEmojiIds(): Promise<string[]>;
+    setAiPaused(paused: boolean): void;
+    retryFailedTasks(): Promise<number>;
+    reanalyzeBatch(ids: string[]): Promise<number>;
+    getAiTasksAll(): Promise<AITaskDetail[]>;
+    deleteAiTask(emojiId: string): Promise<void>;
+    retryAiTask(emojiId: string): Promise<void>;
+    static inject: string[];
+}