mcp-probe-kit 1.11.0 → 1.15.0

package/build/tools/ui-ux-tools.test.d.ts

@@ -0,0 +1,6 @@
+/**
+ * Unit tests for generateFileIndex and generateCreationGuidance functions
+ *
+ * Requirements: 3.2, 3.3, 4.2, 4.3, 4.4, 4.5
+ */
+export {};

package/build/tools/ui-ux-tools.test.js

@@ -0,0 +1,132 @@
+/**
+ * Unit tests for generateFileIndex and generateCreationGuidance functions
+ *
+ * Requirements: 3.2, 3.3, 4.2, 4.3, 4.4, 4.5
+ */
+import { describe, it, expect } from 'vitest';
+import { generateFileIndex, generateCreationGuidance } from './ui-ux-tools.js';
+describe('generateFileIndex', () => {
+    it('should return the correct number of files', () => {
+        const fileIndex = generateFileIndex();
+        // 验证返回7个文件
+        expect(fileIndex).toHaveLength(7);
+    });
+    it('should return files in the correct order', () => {
+        const fileIndex = generateFileIndex();
+        // 验证文件按 order 字段正确排序
+        for (let i = 0; i < fileIndex.length; i++) {
+            expect(fileIndex[i].order).toBe(i + 1);
+        }
+        // 验证具体的文件顺序
+        expect(fileIndex[0].path).toBe('docs/design-system.json');
+        expect(fileIndex[1].path).toBe('docs/design-guidelines/README.md');
+        expect(fileIndex[2].path).toBe('docs/design-guidelines/01-principles.md');
+        expect(fileIndex[3].path).toBe('docs/design-guidelines/02-interaction.md');
+        expect(fileIndex[4].path).toBe('docs/design-guidelines/03-layout.md');
+        expect(fileIndex[5].path).toBe('docs/design-guidelines/04-config.md');
+        expect(fileIndex[6].path).toBe('docs/design-system.md');
+    });
+    it('should have design-system.md as the last file', () => {
+        const fileIndex = generateFileIndex();
+        // 验证最后一个文件是 design-system.md
+        const lastFile = fileIndex[fileIndex.length - 1];
+        expect(lastFile.path).toBe('docs/design-system.md');
+        expect(lastFile.order).toBe(7);
+    });
+    it('should mark all files as required', () => {
+        const fileIndex = generateFileIndex();
+        // 验证所有文件都标记为必需
+        fileIndex.forEach(file => {
+            expect(file.required).toBe(true);
+        });
+    });
+    it('should have valid file metadata', () => {
+        const fileIndex = generateFileIndex();
+        // 验证每个文件都有必需的元数据
+        fileIndex.forEach(file => {
+            expect(file.path).toBeTruthy();
+            expect(file.purpose).toBeTruthy();
+            expect(file.order).toBeGreaterThan(0);
+            expect(typeof file.required).toBe('boolean');
+        });
+    });
+});
+describe('generateCreationGuidance', () => {
+    it('should include topics for all four document types', () => {
+        const guidance = generateCreationGuidance('SaaS');
+        // 验证所有四个文档类型都有主题
+        expect(guidance.principles).toBeDefined();
+        expect(guidance.interaction).toBeDefined();
+        expect(guidance.layout).toBeDefined();
+        expect(guidance.config).toBeDefined();
+        // 验证每个类型都有至少一个主题
+        expect(guidance.principles.length).toBeGreaterThan(0);
+        expect(guidance.interaction.length).toBeGreaterThan(0);
+        expect(guidance.layout.length).toBeGreaterThan(0);
+        expect(guidance.config.length).toBeGreaterThan(0);
+    });
+    it('should include productType in tips', () => {
+        const productType = 'E-commerce';
+        const guidance = generateCreationGuidance(productType);
+        // 验证提示中包含 productType
+        expect(guidance.tips).toBeDefined();
+        expect(guidance.tips.length).toBeGreaterThan(0);
+        // 检查是否有提示提到了产品类型
+        const hasProductTypeMention = guidance.tips.some(tip => tip.includes(productType));
+        expect(hasProductTypeMention).toBe(true);
+    });
+    it('should include stack in tips when provided', () => {
+        const stack = 'react';
+        const guidance = generateCreationGuidance('SaaS', stack);
+        // 验证提示中包含 stack
+        const hasStackMention = guidance.tips.some(tip => tip.toLowerCase().includes(stack.toLowerCase()));
+        expect(hasStackMention).toBe(true);
+    });
+    it('should add stack-specific config topics when stack is provided', () => {
+        const guidanceWithoutStack = generateCreationGuidance('SaaS');
+        const guidanceWithReact = generateCreationGuidance('SaaS', 'react');
+        const guidanceWithVue = generateCreationGuidance('SaaS', 'vue');
+        const guidanceWithTailwind = generateCreationGuidance('SaaS', 'tailwind');
+        // React 应该有额外的配置主题
+        expect(guidanceWithReact.config.length).toBeGreaterThan(guidanceWithoutStack.config.length);
+        // Vue 应该有额外的配置主题
+        expect(guidanceWithVue.config.length).toBeGreaterThan(guidanceWithoutStack.config.length);
+        // Tailwind 应该有额外的配置主题
+        expect(guidanceWithTailwind.config.length).toBeGreaterThan(guidanceWithoutStack.config.length);
+    });
+    it('should include tips array', () => {
+        const guidance = generateCreationGuidance('SaaS');
+        // 验证 tips 数组存在且不为空
+        expect(guidance.tips).toBeDefined();
+        expect(Array.isArray(guidance.tips)).toBe(true);
+        expect(guidance.tips.length).toBeGreaterThan(0);
+    });
+    it('should provide different tips for different product types', () => {
+        const saasGuidance = generateCreationGuidance('SaaS');
+        const ecommerceGuidance = generateCreationGuidance('E-commerce');
+        const healthcareGuidance = generateCreationGuidance('Healthcare');
+        // 验证不同产品类型有不同的提示
+        // 至少应该有一个提示是不同的（因为包含了产品类型）
+        const saasSpecificTips = saasGuidance.tips.filter(tip => tip.includes('SaaS'));
+        const ecommerceSpecificTips = ecommerceGuidance.tips.filter(tip => tip.includes('E-commerce'));
+        const healthcareSpecificTips = healthcareGuidance.tips.filter(tip => tip.includes('Healthcare'));
+        expect(saasSpecificTips.length).toBeGreaterThan(0);
+        expect(ecommerceSpecificTips.length).toBeGreaterThan(0);
+        expect(healthcareSpecificTips.length).toBeGreaterThan(0);
+    });
+    it('should have valid structure for all guidance fields', () => {
+        const guidance = generateCreationGuidance('SaaS', 'react');
+        // 验证所有字段都是字符串数组
+        expect(Array.isArray(guidance.principles)).toBe(true);
+        expect(Array.isArray(guidance.interaction)).toBe(true);
+        expect(Array.isArray(guidance.layout)).toBe(true);
+        expect(Array.isArray(guidance.config)).toBe(true);
+        expect(Array.isArray(guidance.tips)).toBe(true);
+        // 验证数组中的元素都是字符串
+        guidance.principles.forEach(item => expect(typeof item).toBe('string'));
+        guidance.interaction.forEach(item => expect(typeof item).toBe('string'));
+        guidance.layout.forEach(item => expect(typeof item).toBe('string'));
+        guidance.config.forEach(item => expect(typeof item).toBe('string'));
+        guidance.tips.forEach(item => expect(typeof item).toBe('string'));
+    });
+});

package/build/utils/ascii-box-formatter.d.ts

@@ -0,0 +1,29 @@
+/**
+ * ASCII Box 格式化工具
+ *
+ * 将设计系统推荐格式化为漂亮的 ASCII Box 格式
+ */
+import { DesignSystemRecommendation } from './design-reasoning-engine.js';
+export declare class ASCIIBoxFormatter {
+    private readonly BOX_WIDTH;
+    /**
+     * 格式化设计系统推荐
+     */
+    format(recommendation: DesignSystemRecommendation): string;
+    /**
+     * 填充字符串到指定宽度
+     */
+    private pad;
+    /**
+     * 文本换行 - 返回字符串数组
+     */
+    private wrapText;
+    /**
+     * 截断文本
+     */
+    private truncate;
+    /**
+     * 生成 Markdown 格式（备用）
+     */
+    formatMarkdown(recommendation: DesignSystemRecommendation): string;
+}

package/build/utils/ascii-box-formatter.js

@@ -0,0 +1,195 @@
+/**
+ * ASCII Box 格式化工具
+ *
+ * 将设计系统推荐格式化为漂亮的 ASCII Box 格式
+ */
+export class ASCIIBoxFormatter {
+    BOX_WIDTH = 92; // 总宽度（包括两侧的 | 符号）
+    /**
+     * 格式化设计系统推荐
+     */
+    format(recommendation) {
+        const lines = [];
+        const w = this.BOX_WIDTH - 2; // 内容宽度（不包括两侧的 |）
+        // 顶部边框
+        lines.push('+' + '-'.repeat(w) + '+');
+        // 标题
+        const title = `  TARGET: ${recommendation.target} - RECOMMENDED DESIGN SYSTEM`;
+        lines.push('|' + this.pad(title, w) + '|');
+        // 分隔线
+        lines.push('+' + '-'.repeat(w) + '+');
+        // 空行
+        lines.push('|' + ' '.repeat(w) + '|');
+        // 落地页模式
+        lines.push('|' + this.pad(`  PATTERN: ${recommendation.pattern.name}`, w) + '|');
+        lines.push('|' + this.pad(`     Conversion: ${recommendation.pattern.conversion}`, w) + '|');
+        lines.push('|' + this.pad(`     CTA: ${recommendation.pattern.cta}`, w) + '|');
+        lines.push('|' + this.pad('     Sections:', w) + '|');
+        recommendation.pattern.sections.forEach((section, i) => {
+            lines.push('|' + this.pad(`       ${i + 1}. ${section}`, w) + '|');
+        });
+        // 空行
+        lines.push('|' + ' '.repeat(w) + '|');
+        // UI 风格
+        lines.push('|' + this.pad(`  STYLE: ${recommendation.style.primary}`, w) + '|');
+        // Keywords - 处理长文本换行
+        const keywords = recommendation.style.keywords.slice(0, 8).join(', ');
+        const keywordsLines = this.wrapText(`Keywords: ${keywords}`, w - 7);
+        keywordsLines.forEach(line => {
+            lines.push('|' + this.pad(`     ${line}`, w) + '|');
+        });
+        const bestFor = recommendation.style.bestFor.slice(0, 3).join(', ');
+        lines.push('|' + this.pad(`     Best For: ${bestFor}`, w) + '|');
+        lines.push('|' + this.pad(`     Performance: ${recommendation.style.performance} | Accessibility: ${recommendation.style.accessibility}`, w) + '|');
+        // 空行
+        lines.push('|' + ' '.repeat(w) + '|');
+        // 配色方案
+        lines.push('|' + this.pad('  COLORS:', w) + '|');
+        lines.push('|' + this.pad(`     Primary:    ${recommendation.colors.primary}`, w) + '|');
+        lines.push('|' + this.pad(`     Secondary:  ${recommendation.colors.secondary}`, w) + '|');
+        lines.push('|' + this.pad(`     CTA:        ${recommendation.colors.cta}`, w) + '|');
+        lines.push('|' + this.pad(`     Background: ${recommendation.colors.background}`, w) + '|');
+        lines.push('|' + this.pad(`     Text:       ${recommendation.colors.text}`, w) + '|');
+        const notesLines = this.wrapText(`Notes: ${recommendation.colors.notes}`, w - 7);
+        notesLines.forEach(line => {
+            lines.push('|' + this.pad(`     ${line}`, w) + '|');
+        });
+        // 空行
+        lines.push('|' + ' '.repeat(w) + '|');
+        // 字体配对
+        lines.push('|' + this.pad(`  TYPOGRAPHY: ${recommendation.typography.heading} / ${recommendation.typography.body}`, w) + '|');
+        const moodLines = this.wrapText(`Mood: ${recommendation.typography.mood}`, w - 7);
+        moodLines.forEach(line => {
+            lines.push('|' + this.pad(`     ${line}`, w) + '|');
+        });
+        const typoBestFor = recommendation.typography.bestFor.slice(0, 3).join(', ');
+        lines.push('|' + this.pad(`     Best For: ${typoBestFor}`, w) + '|');
+        if (recommendation.typography.googleFontsUrl) {
+            const url = this.truncate(recommendation.typography.googleFontsUrl, 60);
+            lines.push('|' + this.pad(`     Google Fonts: ${url}`, w) + '|');
+        }
+        // 空行
+        lines.push('|' + ' '.repeat(w) + '|');
+        // 效果和动画
+        lines.push('|' + this.pad('  KEY EFFECTS:', w) + '|');
+        const effects = `${recommendation.effects.shadows} + ${recommendation.effects.transitions} + ${recommendation.effects.hover}`;
+        const effectsLines = this.wrapText(effects, w - 7);
+        effectsLines.forEach(line => {
+            lines.push('|' + this.pad(`     ${line}`, w) + '|');
+        });
+        // 空行
+        lines.push('|' + ' '.repeat(w) + '|');
+        // 反模式
+        lines.push('|' + this.pad('  AVOID (Anti-patterns):', w) + '|');
+        const antiPatternsText = recommendation.antiPatterns.slice(0, 4).join(' + ');
+        const antiLines = this.wrapText(antiPatternsText, w - 7);
+        antiLines.forEach(line => {
+            lines.push('|' + this.pad(`     ${line}`, w) + '|');
+        });
+        // 空行
+        lines.push('|' + ' '.repeat(w) + '|');
+        // 检查清单
+        lines.push('|' + this.pad('  PRE-DELIVERY CHECKLIST:', w) + '|');
+        recommendation.checklist.slice(0, 7).forEach(item => {
+            lines.push('|' + this.pad(`     [ ] ${item}`, w) + '|');
+        });
+        // 空行
+        lines.push('|' + ' '.repeat(w) + '|');
+        // 底部边框
+        lines.push('+' + '-'.repeat(w) + '+');
+        return lines.join('\n');
+    }
+    /**
+     * 填充字符串到指定宽度
+     */
+    pad(text, width) {
+        if (text.length >= width) {
+            return text.substring(0, width);
+        }
+        return text + ' '.repeat(width - text.length);
+    }
+    /**
+     * 文本换行 - 返回字符串数组
+     */
+    wrapText(text, maxWidth) {
+        const words = text.split(' ');
+        const lines = [];
+        let currentLine = '';
+        for (const word of words) {
+            const testLine = currentLine ? `${currentLine} ${word}` : word;
+            if (testLine.length <= maxWidth) {
+                currentLine = testLine;
+            }
+            else {
+                if (currentLine) {
+                    lines.push(currentLine);
+                }
+                currentLine = word;
+            }
+        }
+        if (currentLine) {
+            lines.push(currentLine);
+        }
+        return lines;
+    }
+    /**
+     * 截断文本
+     */
+    truncate(text, maxLength) {
+        if (text.length <= maxLength) {
+            return text;
+        }
+        return text.substring(0, maxLength - 3) + '...';
+    }
+    /**
+     * 生成 Markdown 格式（备用）
+     */
+    formatMarkdown(recommendation) {
+        const lines = [];
+        lines.push(`# ${recommendation.target} - Design System`);
+        lines.push('');
+        lines.push(`## Landing Page Pattern: ${recommendation.pattern.name}`);
+        lines.push(`- **Conversion**: ${recommendation.pattern.conversion}`);
+        lines.push(`- **CTA**: ${recommendation.pattern.cta}`);
+        lines.push(`- **Sections**: ${recommendation.pattern.sections.join(', ')}`);
+        lines.push('');
+        lines.push(`## UI Style: ${recommendation.style.primary}`);
+        lines.push(`- **Keywords**: ${recommendation.style.keywords.join(', ')}`);
+        lines.push(`- **Best For**: ${recommendation.style.bestFor.join(', ')}`);
+        lines.push(`- **Performance**: ${recommendation.style.performance}`);
+        lines.push(`- **Accessibility**: ${recommendation.style.accessibility}`);
+        lines.push('');
+        lines.push('## Color Palette');
+        lines.push(`- **Primary**: ${recommendation.colors.primary}`);
+        lines.push(`- **Secondary**: ${recommendation.colors.secondary}`);
+        lines.push(`- **CTA**: ${recommendation.colors.cta}`);
+        lines.push(`- **Background**: ${recommendation.colors.background}`);
+        lines.push(`- **Text**: ${recommendation.colors.text}`);
+        lines.push(`- **Notes**: ${recommendation.colors.notes}`);
+        lines.push('');
+        lines.push(`## Typography: ${recommendation.typography.heading} / ${recommendation.typography.body}`);
+        lines.push(`- **Mood**: ${recommendation.typography.mood}`);
+        lines.push(`- **Best For**: ${recommendation.typography.bestFor.join(', ')}`);
+        if (recommendation.typography.googleFontsUrl) {
+            lines.push(`- **Google Fonts**: ${recommendation.typography.googleFontsUrl}`);
+        }
+        lines.push('');
+        lines.push('## Key Effects');
+        lines.push(`- **Shadows**: ${recommendation.effects.shadows}`);
+        lines.push(`- **Transitions**: ${recommendation.effects.transitions}`);
+        lines.push(`- **Hover**: ${recommendation.effects.hover}`);
+        lines.push(`- **Animations**: ${recommendation.effects.animations}`);
+        lines.push('');
+        lines.push('## Anti-Patterns (Avoid)');
+        recommendation.antiPatterns.forEach(pattern => {
+            lines.push(`- ${pattern}`);
+        });
+        lines.push('');
+        lines.push('## Pre-Delivery Checklist');
+        recommendation.checklist.forEach(item => {
+            lines.push(`- [ ] ${item}`);
+        });
+        lines.push('');
+        return lines.join('\n');
+    }
+}

package/build/utils/bm25.d.ts

@@ -0,0 +1,60 @@
+/**
+ * BM25 搜索引擎实现
+ *
+ * BM25 是一种基于概率的信息检索算法，用于计算文档与查询的相关性得分
+ */
+export interface BM25Document {
+    id: string;
+    text: string;
+    metadata?: Record<string, any>;
+}
+export interface BM25SearchResult {
+    id: string;
+    score: number;
+    metadata?: Record<string, any>;
+}
+export interface BM25Options {
+    k1?: number;
+    b?: number;
+    fields?: string[];
+}
+/**
+ * BM25 搜索引擎
+ */
+export declare class BM25 {
+    private documents;
+    private invertedIndex;
+    private documentLengths;
+    private avgDocLength;
+    private k1;
+    private b;
+    constructor(options?: BM25Options);
+    /**
+     * 分词（简单实现）
+     */
+    private tokenize;
+    /**
+     * 添加文档到索引
+     */
+    addDocument(doc: BM25Document): void;
+    /**
+     * 批量添加文档
+     */
+    addDocuments(docs: BM25Document[]): void;
+    /**
+     * 计算 IDF (Inverse Document Frequency)
+     */
+    private calculateIDF;
+    /**
+     * 计算 BM25 得分
+     */
+    private calculateScore;
+    /**
+     * 搜索文档
+     */
+    search(query: string, limit?: number): BM25SearchResult[];
+    /**
+     * 清空索引
+     */
+    clear(): void;
+}

package/build/utils/bm25.js

@@ -0,0 +1,139 @@
+/**
+ * BM25 搜索引擎实现
+ *
+ * BM25 是一种基于概率的信息检索算法，用于计算文档与查询的相关性得分
+ */
+/**
+ * BM25 搜索引擎
+ */
+export class BM25 {
+    documents = [];
+    invertedIndex = new Map();
+    documentLengths = new Map();
+    avgDocLength = 0;
+    k1;
+    b;
+    constructor(options = {}) {
+        this.k1 = options.k1 ?? 1.5;
+        this.b = options.b ?? 0.75;
+    }
+    /**
+     * 分词（简单实现）
+     */
+    tokenize(text) {
+        return text
+            .toLowerCase()
+            .replace(/[^\w\s\u4e00-\u9fa5]/g, ' ')
+            .split(/\s+/)
+            .filter(token => token.length > 0);
+    }
+    /**
+     * 添加文档到索引
+     */
+    addDocument(doc) {
+        this.documents.push(doc);
+        const tokens = this.tokenize(doc.text);
+        const docLength = tokens.length;
+        this.documentLengths.set(doc.id, docLength);
+        // 构建倒排索引
+        const termFreq = new Map();
+        for (const token of tokens) {
+            termFreq.set(token, (termFreq.get(token) || 0) + 1);
+        }
+        for (const [term, freq] of termFreq) {
+            if (!this.invertedIndex.has(term)) {
+                this.invertedIndex.set(term, new Map());
+            }
+            this.invertedIndex.get(term).set(doc.id, freq);
+        }
+    }
+    /**
+     * 批量添加文档
+     */
+    addDocuments(docs) {
+        for (const doc of docs) {
+            this.addDocument(doc);
+        }
+        // 计算平均文档长度
+        let totalLength = 0;
+        for (const length of this.documentLengths.values()) {
+            totalLength += length;
+        }
+        this.avgDocLength = totalLength / this.documents.length;
+    }
+    /**
+     * 计算 IDF (Inverse Document Frequency)
+     */
+    calculateIDF(term) {
+        const N = this.documents.length;
+        const df = this.invertedIndex.get(term)?.size || 0;
+        if (df === 0)
+            return 0;
+        return Math.log((N - df + 0.5) / (df + 0.5) + 1);
+    }
+    /**
+     * 计算 BM25 得分
+     */
+    calculateScore(docId, queryTerms) {
+        let score = 0;
+        const docLength = this.documentLengths.get(docId) || 0;
+        for (const term of queryTerms) {
+            const termDocs = this.invertedIndex.get(term);
+            if (!termDocs || !termDocs.has(docId)) {
+                continue;
+            }
+            const tf = termDocs.get(docId);
+            const idf = this.calculateIDF(term);
+            // BM25 公式
+            const numerator = tf * (this.k1 + 1);
+            const denominator = tf + this.k1 * (1 - this.b + this.b * (docLength / this.avgDocLength));
+            score += idf * (numerator / denominator);
+        }
+        return score;
+    }
+    /**
+     * 搜索文档
+     */
+    search(query, limit = 10) {
+        const queryTerms = this.tokenize(query);
+        if (queryTerms.length === 0) {
+            return [];
+        }
+        // 获取所有相关文档
+        const relevantDocs = new Set();
+        for (const term of queryTerms) {
+            const termDocs = this.invertedIndex.get(term);
+            if (termDocs) {
+                for (const docId of termDocs.keys()) {
+                    relevantDocs.add(docId);
+                }
+            }
+        }
+        // 计算得分
+        const results = [];
+        for (const docId of relevantDocs) {
+            const score = this.calculateScore(docId, queryTerms);
+            const doc = this.documents.find(d => d.id === docId);
+            if (doc && score > 0) {
+                results.push({
+                    id: docId,
+                    score,
+                    metadata: doc.metadata,
+                });
+            }
+        }
+        // 按得分排序并返回前 N 个
+        return results
+            .sort((a, b) => b.score - a.score)
+            .slice(0, limit);
+    }
+    /**
+     * 清空索引
+     */
+    clear() {
+        this.documents = [];
+        this.invertedIndex.clear();
+        this.documentLengths.clear();
+        this.avgDocLength = 0;
+    }
+}

package/build/utils/cache-manager.d.ts

@@ -0,0 +1,65 @@
+/**
+ * 缓存管理器
+ *
+ * 管理 UI/UX 数据的缓存，支持版本检查和自动更新
+ */
+export interface CacheMetadata {
+    version: string;
+    syncedAt: string;
+    source: string;
+    format: 'csv' | 'json';
+}
+export interface CacheOptions {
+    cacheDir?: string;
+    packageName?: string;
+    autoUpdate?: boolean;
+}
+/**
+ * 缓存管理器
+ */
+export declare class CacheManager {
+    private cacheDir;
+    private packageName;
+    private autoUpdate;
+    constructor(options?: CacheOptions);
+    /**
+     * 确保缓存目录存在
+     */
+    private ensureCacheDir;
+    /**
+     * 获取缓存元数据
+     */
+    getMetadata(): CacheMetadata | null;
+    /**
+     * 检查缓存是否存在
+     */
+    hasCache(): boolean;
+    /**
+     * 获取 npm 包的最新版本
+     */
+    getLatestVersion(): Promise<string>;
+    /**
+     * 检查是否有更新
+     */
+    checkUpdate(): Promise<{
+        hasUpdate: boolean;
+        currentVersion?: string;
+        latestVersion: string;
+    }>;
+    /**
+     * 读取缓存文件
+     */
+    readFile(filename: string): any;
+    /**
+     * 列出所有缓存文件
+     */
+    listFiles(): string[];
+    /**
+     * 清空缓存
+     */
+    clear(): void;
+    /**
+     * 获取缓存目录路径
+     */
+    getCacheDir(): string;
+}