From 8a35c010ccaa71c7860d4f4a97fbe4602125c800 Mon Sep 17 00:00:00 2001 From: linshen <32978552+linshenkx@users.noreply.github.com> Date: Sat, 5 Jul 2025 16:24:21 +0800 Subject: [PATCH] =?UTF-8?q?feat:=20=E6=96=B0=E5=A2=9E=E6=96=87=E4=BB=B6?= =?UTF-8?q?=E5=AD=98=E5=82=A8=E6=94=AF=E6=8C=81=E4=B8=8E=E5=8E=86=E5=8F=B2?= =?UTF-8?q?=E8=AE=B0=E5=BD=95=E7=AE=A1=E7=90=86=E4=BC=98=E5=8C=96?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit - 在`.gitignore`中添加了`prompt-optimizer-datas`以排除相关数据文件。 - 更新`INDEX.md`，新增桌面版文件存储实现的相关信息，确保文档的完整性。 - 在`index.ts`中导出了`FileStorageProvider`，支持文件存储功能。 - 修改`factory.ts`，新增对文件存储类型的支持，并优化错误处理逻辑。 - 在集成测试中模拟了历史记录的保存与验证，确保功能的正确性。 - 更新了多个测试用例，确保历史记录管理逻辑的准确性与一致性。 这些变更旨在提升数据存储的灵活性与历史记录管理的可靠性，确保用户体验的优化。 --- .gitignore | 2 + .../114-desktop-file-storage/README.md | 83 ++++ docs/archives/INDEX.md | 6 + packages/core/src/index.ts | 1 + packages/core/src/services/storage/factory.ts | 10 +- .../services/storage/fileStorageProvider.ts | 302 ++++++++++++++ .../fileStorageProvider-real.test.ts | 250 ++++++++++++ .../prompt/service.integration.test.ts | 33 +- .../core/tests/integration/real-api.test.ts | 30 ++ .../integration/storage-factory-file.test.ts | 119 ++++++ .../unit/prompt-service-enhanced.test.ts | 4 +- .../unit/storage/fileStorageProvider.test.ts | 279 +++++++++++++ .../unit/template/languageService.test.ts | 62 +-- packages/desktop/main.js | 59 ++- packages/extension/src/App.vue | 383 ++++++++++-------- prompt-optimizer-data/storage.json | 11 + 16 files changed, 1425 insertions(+), 209 deletions(-) create mode 100644 docs/archives/114-desktop-file-storage/README.md create mode 100644 packages/core/src/services/storage/fileStorageProvider.ts create mode 100644 packages/core/tests/integration/fileStorageProvider-real.test.ts create mode 100644 packages/core/tests/integration/storage-factory-file.test.ts create mode 100644 packages/core/tests/unit/storage/fileStorageProvider.test.ts create mode 100644 prompt-optimizer-data/storage.json diff --git a/.gitignore b/.gitignore index c7d28f73..e7c1ea8b 100644 --- a/.gitignore +++ b/.gitignore @@ -176,3 +176,5 @@ storybook-static .prettierrc.js.bak *.backup *.bak + +prompt-optimizer-datas \ No newline at end of file diff --git a/docs/archives/114-desktop-file-storage/README.md b/docs/archives/114-desktop-file-storage/README.md new file mode 100644 index 00000000..deecf886 --- /dev/null +++ b/docs/archives/114-desktop-file-storage/README.md @@ -0,0 +1,83 @@ +# 114-桌面版文件存储实现 + +## 📋 概述 + +实现桌面版从内存存储到文件存储的完整切换，为桌面应用提供可靠的数据持久化解决方案。 + +## 🏗️ 核心成果 + +### FileStorageProvider 实现 +- 完全兼容 `IStorageProvider` 接口，一行代码完成切换 +- 延迟写入策略 (500ms) + 内存缓存，性能优异 +- 原子写入操作，确保数据完整性 +- 应用退出前自动保存数据 + +### 存储路径设计 +根据用户偏好，采用可执行文件同级目录存储： + +```typescript +// 路径设置逻辑 +if (app.isPackaged) { + // 生产环境：可执行文件目录/prompt-optimizer-data/ + const execDir = path.dirname(process.execPath); + userDataPath = path.join(execDir, 'prompt-optimizer-data'); +} else { + // 开发环境：项目根目录/prompt-optimizer-data/ + userDataPath = path.join(__dirname, '..', '..', 'prompt-optimizer-data'); +} +``` + +**优势**： +- ✅ 便于管理和查找数据文件 +- ✅ 数据与应用在同一位置，便于备份迁移 +- ✅ 目录名明确标识，避免与其他应用混淆 + +### 架构集成 +```typescript +// 简单的一行切换 +// const storage = StorageFactory.create('memory') // 旧方式 +const storage = new FileStorageProvider(userDataPath) // 新方式 +``` + +## ✅ 验证结果 + +### 测试覆盖 +- **单元测试**: 18/18 通过 (Mock文件系统) +- **集成测试**: 12/12 通过 (真实文件操作) +- **性能基准**: 写入4ms，读取0ms (内存缓存) + +### 实际验证 +- ✅ 桌面版本成功启动 +- ✅ 自动创建 `prompt-optimizer-data/storage.json` 文件 +- ✅ 数据持久化正常工作 +- ✅ 应用重启后配置和历史记录保持 + +## 🔧 技术特性 + +- **延迟写入**: 正常操作延迟500ms，批量操作立即写入 +- **原子操作**: 临时文件写入 → 验证 → 重命名替换 +- **错误恢复**: 文件损坏时自动创建新存储 +- **退出保护**: 应用退出前强制保存所有数据 + +## 📊 项目价值 + +### 用户价值 +- **数据安全**: 用户数据得到可靠的持久化保护 +- **使用体验**: 应用重启后数据保持，提升用户体验 +- **功能完整**: 桌面版功能与Web版对等 + +### 技术价值 +- **架构完善**: 为桌面应用提供了完整的存储解决方案 +- **接口设计**: 良好的抽象层设计让存储切换变得简单 +- **性能优化**: 实现了高性能的文件存储机制 + +--- + +## 附录：测试修复记录 + +在实现过程中顺便修复了16个测试失败问题： +- **架构问题**: Service层与UI层职责分离 +- **异步调用**: TemplateLanguageService测试缺少await +- **集成测试**: 正确模拟UI层历史记录保存行为 + +修复后测试结果：291个测试通过，9个跳过 ✅ diff --git a/docs/archives/INDEX.md b/docs/archives/INDEX.md index 63ef71d6..304ccb34 100644 --- a/docs/archives/INDEX.md +++ b/docs/archives/INDEX.md @@ -84,6 +84,11 @@ - 依赖注入优化 - 服务接口标准化 +- **[114-desktop-file-storage](./114-desktop-file-storage/)** - 桌面版文件存储实现 💾 + - 实现FileStorageProvider替代内存存储 + - 完整的数据持久化解决方案 + - 高性能文件I/O和错误恢复机制 + ## 🔍 快速查找指南 ### 按问题类型查找 @@ -94,6 +99,7 @@ - **主题问题** → 109-theme-system - **模板问题** → 106-template-management - **组件问题** → 107-component-standardization +- **存储问题** → 114-desktop-file-storage ### 按技术栈查找 - **Electron相关** → 103, 110, 111, 112 diff --git a/packages/core/src/index.ts b/packages/core/src/index.ts index dde9dee9..dbf4f120 100644 --- a/packages/core/src/index.ts +++ b/packages/core/src/index.ts @@ -37,6 +37,7 @@ export { StorageFactory } from './services/storage/factory' export { DexieStorageProvider } from './services/storage/dexieStorageProvider' export { LocalStorageProvider } from './services/storage/localStorageProvider' export { MemoryStorageProvider } from './services/storage/memoryStorageProvider' +export { FileStorageProvider } from './services/storage/fileStorageProvider' // 导出提示词服务相关 export { PromptService } from './services/prompt/service' diff --git a/packages/core/src/services/storage/factory.ts b/packages/core/src/services/storage/factory.ts index 5b1836ad..c9be3159 100644 --- a/packages/core/src/services/storage/factory.ts +++ b/packages/core/src/services/storage/factory.ts @@ -3,7 +3,7 @@ import { LocalStorageProvider } from './localStorageProvider'; import { DexieStorageProvider } from './dexieStorageProvider'; import { MemoryStorageProvider } from './memoryStorageProvider'; -export type StorageType = 'localStorage' | 'dexie' | 'memory'; +export type StorageType = 'localStorage' | 'dexie' | 'memory' | 'file'; /** * 存储工厂类 @@ -34,6 +34,9 @@ export class StorageFactory { case 'memory': instance = new MemoryStorageProvider(); break; + case 'file': + throw new Error('File storage must be created directly with FileStorageProvider constructor'); + break; default: throw new Error(`Unsupported storage type: ${type}`); } @@ -76,6 +79,11 @@ export class StorageFactory { types.push('dexie'); } + // 检查 Electron 环境支持文件存储 + if (typeof process !== 'undefined' && process.versions?.electron) { + types.push('file'); + } + return types; } diff --git a/packages/core/src/services/storage/fileStorageProvider.ts b/packages/core/src/services/storage/fileStorageProvider.ts new file mode 100644 index 00000000..2c004215 --- /dev/null +++ b/packages/core/src/services/storage/fileStorageProvider.ts @@ -0,0 +1,302 @@ +import * as fs from 'fs/promises'; +import * as path from 'path'; +import { IStorageProvider } from './types'; +import { StorageError } from './errors'; + +/** + * 基于文件的存储提供器 + * 专为Electron桌面环境设计，使用JSON文件持久化存储数据 + * + * 特性： + * - 延迟写入优化性能，减少I/O操作 + * - 内存缓存提供快速读取 + * - 原子写入确保数据完整性 + * - 关键时刻立即写入保证数据安全 + */ +export class FileStorageProvider implements IStorageProvider { + private filePath: string; + private data: Map = new Map(); + private writeTimeout: NodeJS.Timeout | null = null; + private isDirty: boolean = false; + private writeLock: Promise = Promise.resolve(); + private initialized: boolean = false; + + // 配置常量 + private readonly WRITE_DELAY = 500; // 500ms延迟写入 + private readonly TEMP_FILE_SUFFIX = '.tmp'; + + constructor(userDataPath: string) { + if (!userDataPath) { + throw new StorageError('FileStorageProvider requires userDataPath parameter', 'read'); + } + + this.filePath = path.join(userDataPath, 'storage.json'); + } + + /** + * 确保存储已初始化 + */ + private async ensureInitialized(): Promise { + if (!this.initialized) { + await this.initialize(); + } + } + + /** + * 初始化存储，加载现有数据 + */ + private async initialize(): Promise { + try { + await this.loadFromFile(); + this.initialized = true; + } catch (error) { + const errorMessage = error instanceof Error ? error.message : 'Unknown error'; + throw new StorageError(`Failed to initialize file storage: ${errorMessage}`, 'read'); + } + } + + /** + * 从文件加载数据到内存 + */ + private async loadFromFile(): Promise { + try { + // 检查文件是否存在 + try { + await fs.access(this.filePath); + } catch { + // 文件不存在，创建空存储 + console.log('[FileStorage] Storage file not found, creating new storage'); + this.data = new Map(); + await this.saveToFile(); + return; + } + + // 读取文件内容 + const content = await fs.readFile(this.filePath, 'utf8'); + + // 验证JSON格式 + if (!this.validateJSON(content)) { + console.warn('[FileStorage] Storage file corrupted, creating new storage'); + this.data = new Map(); + await this.saveToFile(); + return; + } + + // 解析并加载数据 + const parsed = JSON.parse(content); + this.data = new Map(Object.entries(parsed || {})); + + console.log(`[FileStorage] Loaded ${this.data.size} items from storage`); + + } catch (error) { + console.error('[FileStorage] Failed to load from file:', error); + // 创建新的空存储 + this.data = new Map(); + await this.saveToFile(); + } + } + + /** + * 将内存数据保存到文件 + */ + private async saveToFile(): Promise { + const data = Object.fromEntries(this.data); + const jsonString = JSON.stringify(data, null, 2); + await this.atomicWrite(jsonString); + } + + /** + * 原子写入文件 + */ + private async atomicWrite(data: string): Promise { + const tempPath = this.filePath + this.TEMP_FILE_SUFFIX; + + try { + // 确保目录存在 + await fs.mkdir(path.dirname(this.filePath), { recursive: true }); + + // 1. 写入临时文件 + await fs.writeFile(tempPath, data, 'utf8'); + + // 2. 验证文件格式 + if (!this.validateJSON(data)) { + throw new Error('Invalid JSON format'); + } + + // 3. 原子性重命名 + await fs.rename(tempPath, this.filePath); + + } catch (error) { + // 清理临时文件 + try { + await fs.unlink(tempPath); + } catch {} + + const errorMessage = error instanceof Error ? error.message : 'Unknown error'; + throw new StorageError(`Atomic write failed: ${errorMessage}`, 'write'); + } + } + + /** + * 验证JSON格式 + */ + private validateJSON(data: string): boolean { + try { + JSON.parse(data); + return true; + } catch { + return false; + } + } + + /** + * 调度延迟写入 + */ + private scheduleWrite(): void { + this.isDirty = true; + + // 如果已有待写入任务，重置计时器 + if (this.writeTimeout) { + clearTimeout(this.writeTimeout); + } + + this.writeTimeout = setTimeout(async () => { + if (this.isDirty) { + try { + await this.acquireWriteLock(async () => { + await this.saveToFile(); + this.isDirty = false; + }); + } catch (error) { + console.error('[FileStorage] Scheduled write failed:', error); + } + } + this.writeTimeout = null; + }, this.WRITE_DELAY); + } + + /** + * 立即写入（关键时刻使用） + */ + async flush(): Promise { + if (this.writeTimeout) { + clearTimeout(this.writeTimeout); + this.writeTimeout = null; + } + + if (this.isDirty) { + await this.acquireWriteLock(async () => { + await this.saveToFile(); + this.isDirty = false; + }); + } + } + + /** + * 获取写入锁，确保写入操作串行执行 + */ + private async acquireWriteLock(operation: () => Promise): Promise { + const currentLock = this.writeLock; + let resolveLock: () => void; + + this.writeLock = new Promise((resolve) => { + resolveLock = resolve; + }); + + try { + await currentLock; + const result = await operation(); + return result; + } finally { + resolveLock!(); + } + } + + // IStorageProvider接口实现 + + async getItem(key: string): Promise { + await this.ensureInitialized(); + return this.data.get(key) || null; + } + + async setItem(key: string, value: string): Promise { + await this.ensureInitialized(); + this.data.set(key, value); + this.scheduleWrite(); // 延迟写入 + } + + async removeItem(key: string): Promise { + await this.ensureInitialized(); + this.data.delete(key); + this.scheduleWrite(); // 延迟写入 + } + + async clearAll(): Promise { + await this.ensureInitialized(); + this.data.clear(); + // 强制写入，即使没有脏数据 + await this.acquireWriteLock(async () => { + await this.saveToFile(); + }); + } + + async updateData(key: string, modifier: (currentValue: T | null) => T): Promise { + await this.ensureInitialized(); + + try { + // 读取当前值 + const currentData = this.data.get(key); + const currentValue: T | null = currentData ? JSON.parse(currentData) : null; + + // 应用修改 - 允许业务逻辑错误透传 + const newValue = modifier(currentValue); + + // 写入新值 + this.data.set(key, JSON.stringify(newValue)); + this.scheduleWrite(); // 延迟写入 + + } catch (error) { + // 业务逻辑错误直接透传，保持错误类型 + if (error instanceof Error && + (error.name.includes('Error') || + error.constructor.name !== 'Error' || + error.message.includes('模型') || + error.message.includes('不存在'))) { + throw error; + } + // 只有真正的存储错误才包装为StorageError + throw new StorageError(`Data update failed: ${key}`, 'write'); + } + } + + async batchUpdate(operations: Array<{ + key: string; + operation: 'set' | 'remove'; + value?: string; + }>): Promise { + await this.ensureInitialized(); + + try { + for (const op of operations) { + if (op.operation === 'set' && op.value !== undefined) { + this.data.set(op.key, op.value); + } else if (op.operation === 'remove') { + this.data.delete(op.key); + } + } + + await this.flush(); // 批量操作后立即写入 + + } catch (error) { + throw new StorageError('Batch update failed', 'write'); + } + } + + getCapabilities() { + return { + supportsAtomic: true, + supportsBatch: true, + maxStorageSize: undefined // 文件存储无固定大小限制 + }; + } +} diff --git a/packages/core/tests/integration/fileStorageProvider-real.test.ts b/packages/core/tests/integration/fileStorageProvider-real.test.ts new file mode 100644 index 00000000..9507bbb9 --- /dev/null +++ b/packages/core/tests/integration/fileStorageProvider-real.test.ts @@ -0,0 +1,250 @@ +import { describe, it, expect, beforeEach, afterEach } from 'vitest'; +import * as fs from 'fs/promises'; +import * as path from 'path'; +import { FileStorageProvider } from '../../src/services/storage/fileStorageProvider'; +import { StorageError } from '../../src/services/storage/errors'; + +describe('FileStorageProvider - Real File System Integration', () => { + let provider: FileStorageProvider; + let testDir: string; + let storageFile: string; + + beforeEach(async () => { + // 在项目的tests目录下创建临时测试目录 + testDir = path.join(__dirname, '..', '..', 'temp-test-storage'); + storageFile = path.join(testDir, 'storage.json'); + + // 确保测试目录存在 + await fs.mkdir(testDir, { recursive: true }); + + // 创建FileStorageProvider实例 + provider = new FileStorageProvider(testDir); + }); + + afterEach(async () => { + // 清理测试文件和目录 + try { + await fs.rm(testDir, { recursive: true, force: true }); + } catch (error) { + console.warn('Failed to cleanup test directory:', error); + } + }); + + describe('Real file operations', () => { + it('should create storage file when it does not exist', async () => { + // 确保文件不存在 + await expect(fs.access(storageFile)).rejects.toThrow(); + + // 执行操作触发文件创建 + await provider.setItem('test-key', 'test-value'); + + // 等待延迟写入完成 + await new Promise(resolve => setTimeout(resolve, 600)); + + // 验证文件被创建 + await expect(fs.access(storageFile)).resolves.toBeUndefined(); + + // 验证文件内容 + const content = await fs.readFile(storageFile, 'utf8'); + const data = JSON.parse(content); + expect(data['test-key']).toBe('test-value'); + }); + + it('should load existing data from real file', async () => { + // 手动创建测试文件 + const testData = { 'existing-key': 'existing-value' }; + await fs.writeFile(storageFile, JSON.stringify(testData), 'utf8'); + + // 创建新的provider实例来加载数据 + const newProvider = new FileStorageProvider(testDir); + + // 验证数据被正确加载 + const value = await newProvider.getItem('existing-key'); + expect(value).toBe('existing-value'); + }); + + it('should handle corrupted file gracefully', async () => { + // 创建损坏的JSON文件 + await fs.writeFile(storageFile, 'invalid json content', 'utf8'); + + // 创建新的provider实例 + const newProvider = new FileStorageProvider(testDir); + + // 应该能够处理损坏的文件并创建新的存储 + await newProvider.setItem('recovery-key', 'recovery-value'); + + // 等待写入完成 + await new Promise(resolve => setTimeout(resolve, 600)); + + // 验证文件被重新创建且内容正确 + const content = await fs.readFile(storageFile, 'utf8'); + const data = JSON.parse(content); + expect(data['recovery-key']).toBe('recovery-value'); + }); + + it('should persist data across provider instances', async () => { + // 使用第一个provider写入数据 + await provider.setItem('persist-key', 'persist-value'); + await provider.setItem('another-key', 'another-value'); + + // 立即写入 + await provider.flush(); + + // 创建新的provider实例 + const newProvider = new FileStorageProvider(testDir); + + // 验证数据持久化 + expect(await newProvider.getItem('persist-key')).toBe('persist-value'); + expect(await newProvider.getItem('another-key')).toBe('another-value'); + }); + + it('should handle batch operations with real files', async () => { + const operations = [ + { key: 'batch-key-1', operation: 'set' as const, value: 'batch-value-1' }, + { key: 'batch-key-2', operation: 'set' as const, value: 'batch-value-2' }, + { key: 'batch-key-3', operation: 'set' as const, value: 'batch-value-3' } + ]; + + await provider.batchUpdate(operations); + + // 验证数据在内存中正确 + expect(await provider.getItem('batch-key-1')).toBe('batch-value-1'); + expect(await provider.getItem('batch-key-2')).toBe('batch-value-2'); + expect(await provider.getItem('batch-key-3')).toBe('batch-value-3'); + + // 验证文件存在 + await expect(fs.access(storageFile)).resolves.toBeUndefined(); + }); + + it('should handle clearAll with real files', async () => { + // 先添加一些数据 + await provider.setItem('clear-key-1', 'clear-value-1'); + await provider.setItem('clear-key-2', 'clear-value-2'); + await provider.flush(); + + // 验证数据存在 + let content = await fs.readFile(storageFile, 'utf8'); + let data = JSON.parse(content); + expect(Object.keys(data)).toHaveLength(2); + + // 清空所有数据 + await provider.clearAll(); + + // 验证文件被清空 + content = await fs.readFile(storageFile, 'utf8'); + data = JSON.parse(content); + expect(Object.keys(data)).toHaveLength(0); + }); + + it('should handle updateData with real files', async () => { + // 初始化计数器 + await provider.setItem('counter', '5'); + await provider.flush(); + + // 使用updateData增加计数器 + await provider.updateData('counter', (current) => { + return (current || 0) + 1; + }); + + await provider.flush(); + + // 验证文件中的数据被正确更新 + const content = await fs.readFile(storageFile, 'utf8'); + const data = JSON.parse(content); + expect(data['counter']).toBe('6'); + }); + + it('should handle concurrent operations safely', async () => { + // 串行执行写入操作以避免文件冲突 + for (let i = 0; i < 10; i++) { + await provider.setItem(`concurrent-key-${i}`, `concurrent-value-${i}`); + } + + await provider.flush(); + + // 验证所有数据都被正确写入 + const content = await fs.readFile(storageFile, 'utf8'); + const data = JSON.parse(content); + + for (let i = 0; i < 10; i++) { + expect(data[`concurrent-key-${i}`]).toBe(`concurrent-value-${i}`); + } + }); + + it('should handle removeItem with real files', async () => { + // 添加测试数据 + await provider.setItem('remove-key-1', 'remove-value-1'); + await provider.setItem('remove-key-2', 'remove-value-2'); + await provider.flush(); + + // 删除一个键 + await provider.removeItem('remove-key-1'); + await provider.flush(); + + // 验证文件中的数据 + const content = await fs.readFile(storageFile, 'utf8'); + const data = JSON.parse(content); + + expect(data['remove-key-1']).toBeUndefined(); + expect(data['remove-key-2']).toBe('remove-value-2'); + }); + }); + + describe('Error handling with real file system', () => { + it('should throw error when directory cannot be created', async () => { + // 尝试在只读位置创建存储（如果可能的话） + // 这个测试可能需要根据具体环境调整 + const invalidPath = '/invalid/readonly/path'; + const invalidProvider = new FileStorageProvider(invalidPath); + + // 在某些系统上这可能会成功，所以我们只测试基本的错误处理 + try { + await invalidProvider.setItem('test', 'test'); + await invalidProvider.flush(); + } catch (error) { + expect(error).toBeInstanceOf(StorageError); + } + }); + + it('should handle temporary file cleanup on write failure', async () => { + // 这个测试比较难模拟，但我们可以验证正常情况下没有临时文件残留 + await provider.setItem('temp-test', 'temp-value'); + await provider.flush(); + + // 检查没有临时文件残留 + const files = await fs.readdir(testDir); + const tempFiles = files.filter(file => file.endsWith('.tmp')); + expect(tempFiles).toHaveLength(0); + }); + }); + + describe('Performance with real files', () => { + it('should handle large data efficiently', async () => { + const largeValue = 'x'.repeat(10000); // 10KB的数据 + + const startTime = Date.now(); + + // 写入大量数据 + for (let i = 0; i < 100; i++) { + await provider.setItem(`large-key-${i}`, largeValue); + } + + await provider.flush(); + + const writeTime = Date.now() - startTime; + + // 读取数据 + const readStartTime = Date.now(); + for (let i = 0; i < 100; i++) { + await provider.getItem(`large-key-${i}`); + } + const readTime = Date.now() - readStartTime; + + // 性能断言（这些值可能需要根据实际情况调整） + expect(writeTime).toBeLessThan(5000); // 写入应该在5秒内完成 + expect(readTime).toBeLessThan(100); // 读取应该在100ms内完成（内存缓存） + + console.log(`Write time: ${writeTime}ms, Read time: ${readTime}ms`); + }); + }); +}); diff --git a/packages/core/tests/integration/prompt/service.integration.test.ts b/packages/core/tests/integration/prompt/service.integration.test.ts index 9cfbdd66..b65e1fa6 100644 --- a/packages/core/tests/integration/prompt/service.integration.test.ts +++ b/packages/core/tests/integration/prompt/service.integration.test.ts @@ -80,6 +80,16 @@ describe('PromptService Integration Tests', () => { expect(typeof result).toBe('string'); expect(result.length).toBeGreaterThan(0); + // 模拟UI层保存历史记录 + await historyManager.createNewChain({ + id: `test_${Date.now()}`, + originalPrompt: request.targetPrompt, + optimizedPrompt: result, + type: 'optimize', + modelKey: request.modelKey, + timestamp: Date.now() + }); + // 验证历史记录 const records = await historyManager.getRecords(); expect(records.length).toBe(1); @@ -150,10 +160,29 @@ describe('PromptService Integration Tests', () => { expect(typeof result).toBe('string'); expect(result.length).toBeGreaterThan(0); + // 模拟UI层保存历史记录 - 对于迭代，需要先创建一个链，然后添加迭代 + const chain = await historyManager.createNewChain({ + id: `test_${Date.now()}`, + originalPrompt: 'Write a simple greeting', + optimizedPrompt: 'Hello world', + type: 'optimize', + modelKey: 'test-gemini', + timestamp: Date.now() + }); + + await historyManager.addIteration({ + chainId: chain.chainId, + originalPrompt: 'Write a simple greeting', + optimizedPrompt: result, + modelKey: 'test-gemini', + templateId: 'iterate', + iterationNote: 'Make it more formal' + }); + // 验证历史记录 const records = await historyManager.getRecords(); - expect(records.length).toBe(1); - expect(records[0].type).toBe('iterate'); + expect(records.length).toBe(2); // 一个初始记录 + 一个迭代记录 + expect(records.find(r => r.type === 'iterate')).toBeDefined(); }, 30000); it.runIf(hasGeminiKey)('should work with message-based iterate templates', async () => { diff --git a/packages/core/tests/integration/real-api.test.ts b/packages/core/tests/integration/real-api.test.ts index 094ce36e..6d2134a1 100644 --- a/packages/core/tests/integration/real-api.test.ts +++ b/packages/core/tests/integration/real-api.test.ts @@ -177,6 +177,16 @@ describe('Real API Integration Tests', () => { expect(typeof result).toBe('string') expect(result.length).toBeGreaterThan(0) + // 模拟UI层保存历史记录 + await historyManager.createNewChain({ + id: `test_${Date.now()}`, + originalPrompt: request.targetPrompt, + optimizedPrompt: result, + type: 'optimize', + modelKey: request.modelKey, + timestamp: Date.now() + }) + // 验证历史记录已保存 const records = await historyManager.getRecords() expect(records.length).toBe(1) @@ -216,6 +226,16 @@ describe('Real API Integration Tests', () => { expect(typeof result).toBe('string') expect(result.length).toBeGreaterThan(0) + // 模拟UI层保存历史记录 + await historyManager.createNewChain({ + id: `test_${Date.now()}`, + originalPrompt: request.targetPrompt, + optimizedPrompt: result, + type: 'optimize', + modelKey: request.modelKey, + timestamp: Date.now() + }) + // 验证历史记录已保存 const records = await historyManager.getRecords() expect(records.length).toBe(1) @@ -259,6 +279,16 @@ describe('Real API Integration Tests', () => { expect(typeof optimizeResult).toBe('string') expect(optimizeResult.length).toBeGreaterThan(0) + // 模拟UI层保存历史记录 + await historyManager.createNewChain({ + id: `test_${Date.now()}`, + originalPrompt: request.targetPrompt, + optimizedPrompt: optimizeResult, + type: 'optimize', + modelKey: request.modelKey, + timestamp: Date.now() + }) + // 验证历史记录已保存 const records = await historyManager.getRecords() expect(records.length).toBe(1) diff --git a/packages/core/tests/integration/storage-factory-file.test.ts b/packages/core/tests/integration/storage-factory-file.test.ts new file mode 100644 index 00000000..cba7b6d9 --- /dev/null +++ b/packages/core/tests/integration/storage-factory-file.test.ts @@ -0,0 +1,119 @@ +import { describe, it, expect, beforeEach, afterEach, vi } from 'vitest'; +import { StorageFactory } from '../../src/services/storage/factory'; +import { FileStorageProvider } from '../../src/services/storage/fileStorageProvider'; + +describe('StorageFactory - File Storage Integration', () => { + beforeEach(() => { + vi.clearAllMocks(); + StorageFactory.reset(); + }); + + afterEach(() => { + StorageFactory.reset(); + }); + + describe('getSupportedTypes', () => { + it('should include file storage in Electron environment', () => { + // Mock Electron environment + const originalProcess = global.process; + global.process = { + ...originalProcess, + versions: { electron: '37.1.0', node: '20.0.0' } + } as any; + + const supportedTypes = StorageFactory.getSupportedTypes(); + + expect(supportedTypes).toContain('file'); + expect(supportedTypes).toContain('memory'); + + global.process = originalProcess; + }); + + it('should not include file storage in non-Electron environment', () => { + // Mock non-Electron environment + const originalProcess = global.process; + global.process = { + ...originalProcess, + versions: { node: '20.0.0' } + } as any; + + const supportedTypes = StorageFactory.getSupportedTypes(); + + expect(supportedTypes).not.toContain('file'); + expect(supportedTypes).toContain('memory'); + + global.process = originalProcess; + }); + }); + + describe('isSupported', () => { + it('should return true for file storage in Electron environment', () => { + // Mock Electron environment + const originalProcess = global.process; + global.process = { + ...originalProcess, + versions: { electron: '37.1.0', node: '20.0.0' } + } as any; + + const isSupported = StorageFactory.isSupported('file'); + + expect(isSupported).toBe(true); + + global.process = originalProcess; + }); + + it('should return false for file storage in non-Electron environment', () => { + // Mock non-Electron environment + const originalProcess = global.process; + global.process = { + ...originalProcess, + versions: { node: '20.0.0' } + } as any; + + const isSupported = StorageFactory.isSupported('file'); + + expect(isSupported).toBe(false); + + global.process = originalProcess; + }); + }); + + describe('create', () => { + it('should create FileStorageProvider instance for file type', () => { + // Create FileStorageProvider directly with userDataPath to avoid Electron dependency + const provider = new FileStorageProvider('/mock/user/data'); + + expect(provider).toBeInstanceOf(FileStorageProvider); + }); + + it('should return same instance for multiple calls (singleton)', () => { + // Test the singleton behavior by creating providers through factory + // We'll test this with memory storage since file storage requires Electron + const provider1 = StorageFactory.create('memory'); + const provider2 = StorageFactory.create('memory'); + + expect(provider1).toBe(provider2); + }); + + it('should throw error for unsupported storage type', () => { + expect(() => { + // @ts-ignore - intentionally passing invalid type + StorageFactory.create('invalid'); + }).toThrow('Unsupported storage type: invalid'); + }); + }); + + describe('type definitions', () => { + it('should include file in StorageType union', () => { + // This is a compile-time test - if it compiles, the type is correct + const fileType: 'file' = 'file'; + + // Test that the type is accepted (compile-time check) + expect(fileType).toBe('file'); + + // Test that FileStorageProvider can be created directly + const provider = new FileStorageProvider('/mock/user/data'); + expect(provider).toBeDefined(); + }); + }); +}); diff --git a/packages/core/tests/unit/prompt-service-enhanced.test.ts b/packages/core/tests/unit/prompt-service-enhanced.test.ts index 915459f7..ec1024e0 100644 --- a/packages/core/tests/unit/prompt-service-enhanced.test.ts +++ b/packages/core/tests/unit/prompt-service-enhanced.test.ts @@ -67,7 +67,7 @@ describe('PromptService Enhanced Features', () => { expect(result).toBe('optimized result') expect(mockLLMService.sendMessage).toHaveBeenCalled() - expect(mockHistoryManager.addRecord).toHaveBeenCalled() + // 注意：历史记录保存由UI层处理，Service层不保存历史记录 }) it('should optimize user prompt successfully', async () => { @@ -202,7 +202,7 @@ describe('PromptService Enhanced Features', () => { expect(callbacks.onToken).toHaveBeenCalledWith('test') expect(callbacks.onToken).toHaveBeenCalledWith(' result') expect(callbacks.onComplete).toHaveBeenCalled() - expect(mockHistoryManager.addRecord).toHaveBeenCalled() + // 注意：历史记录保存由UI层处理，Service层不保存历史记录 }) it('should handle missing model key', async () => { diff --git a/packages/core/tests/unit/storage/fileStorageProvider.test.ts b/packages/core/tests/unit/storage/fileStorageProvider.test.ts new file mode 100644 index 00000000..3247849f --- /dev/null +++ b/packages/core/tests/unit/storage/fileStorageProvider.test.ts @@ -0,0 +1,279 @@ +import { describe, it, expect, beforeEach, afterEach, vi } from 'vitest'; +import * as fs from 'fs/promises'; +import * as path from 'path'; +import { FileStorageProvider } from '../../../src/services/storage/fileStorageProvider'; +import { StorageError } from '../../../src/services/storage/errors'; + +// Mock fs module +vi.mock('fs/promises'); +const mockFs = vi.mocked(fs); + +// Mock path module +vi.mock('path'); +const mockPath = vi.mocked(path); + +describe('FileStorageProvider', () => { + let provider: FileStorageProvider; + let mockUserDataPath: string; + let mockFilePath: string; + + beforeEach(() => { + vi.clearAllMocks(); + + mockUserDataPath = '/mock/user/data'; + mockFilePath = '/mock/user/data/storage.json'; + + // Setup path mocks + mockPath.join.mockReturnValue(mockFilePath); + mockPath.dirname.mockReturnValue(mockUserDataPath); + + provider = new FileStorageProvider(mockUserDataPath); + }); + + afterEach(() => { + vi.clearAllMocks(); + }); + + describe('constructor', () => { + it('should create instance with provided user data path', () => { + expect(mockPath.join).toHaveBeenCalledWith(mockUserDataPath, 'storage.json'); + }); + + it('should throw error when no path provided', () => { + expect(() => new FileStorageProvider('')).toThrow(StorageError); + }); + }); + + describe('initialization', () => { + it('should create new storage when file does not exist', async () => { + // Mock file not exists + mockFs.access.mockRejectedValue(new Error('File not found')); + mockFs.mkdir.mockResolvedValue(undefined); + mockFs.writeFile.mockResolvedValue(undefined); + mockFs.rename.mockResolvedValue(undefined); + + const result = await provider.getItem('test-key'); + + expect(result).toBeNull(); + expect(mockFs.access).toHaveBeenCalledWith(mockFilePath); + expect(mockFs.writeFile).toHaveBeenCalled(); + }); + + it('should load existing data from file', async () => { + const mockData = { 'test-key': 'test-value' }; + const mockContent = JSON.stringify(mockData); + + mockFs.access.mockResolvedValue(undefined); + mockFs.readFile.mockResolvedValue(mockContent); + + const result = await provider.getItem('test-key'); + + expect(result).toBe('test-value'); + expect(mockFs.readFile).toHaveBeenCalledWith(mockFilePath, 'utf8'); + }); + + it('should handle corrupted file by creating new storage', async () => { + mockFs.access.mockResolvedValue(undefined); + mockFs.readFile.mockResolvedValue('invalid json'); + mockFs.mkdir.mockResolvedValue(undefined); + mockFs.writeFile.mockResolvedValue(undefined); + mockFs.rename.mockResolvedValue(undefined); + + const result = await provider.getItem('test-key'); + + expect(result).toBeNull(); + expect(mockFs.writeFile).toHaveBeenCalled(); + }); + }); + + describe('getItem', () => { + beforeEach(async () => { + // Setup initialized storage + mockFs.access.mockResolvedValue(undefined); + mockFs.readFile.mockResolvedValue('{"test-key":"test-value"}'); + }); + + it('should return stored value', async () => { + const result = await provider.getItem('test-key'); + expect(result).toBe('test-value'); + }); + + it('should return null for non-existent key', async () => { + const result = await provider.getItem('non-existent'); + expect(result).toBeNull(); + }); + }); + + describe('setItem', () => { + beforeEach(async () => { + // Setup initialized storage + mockFs.access.mockRejectedValue(new Error('File not found')); + mockFs.mkdir.mockResolvedValue(undefined); + mockFs.writeFile.mockResolvedValue(undefined); + mockFs.rename.mockResolvedValue(undefined); + }); + + it('should store value and schedule write', async () => { + await provider.setItem('new-key', 'new-value'); + + const result = await provider.getItem('new-key'); + expect(result).toBe('new-value'); + }); + + it('should update existing value', async () => { + await provider.setItem('key', 'value1'); + await provider.setItem('key', 'value2'); + + const result = await provider.getItem('key'); + expect(result).toBe('value2'); + }); + }); + + describe('removeItem', () => { + beforeEach(async () => { + // Setup initialized storage with data + mockFs.access.mockResolvedValue(undefined); + mockFs.readFile.mockResolvedValue('{"test-key":"test-value"}'); + mockFs.mkdir.mockResolvedValue(undefined); + mockFs.writeFile.mockResolvedValue(undefined); + mockFs.rename.mockResolvedValue(undefined); + }); + + it('should remove existing item', async () => { + await provider.removeItem('test-key'); + + const result = await provider.getItem('test-key'); + expect(result).toBeNull(); + }); + + it('should handle removal of non-existent item', async () => { + await provider.removeItem('non-existent'); + + // Should not throw error + const result = await provider.getItem('test-key'); + expect(result).toBe('test-value'); // Original data should remain + }); + }); + + describe('clearAll', () => { + beforeEach(async () => { + // Setup initialized storage with data + mockFs.access.mockResolvedValue(undefined); + mockFs.readFile.mockResolvedValue('{"key1":"value1","key2":"value2"}'); + mockFs.mkdir.mockResolvedValue(undefined); + mockFs.writeFile.mockResolvedValue(undefined); + mockFs.rename.mockResolvedValue(undefined); + }); + + it('should clear all data and write immediately', async () => { + // First ensure data is loaded + await provider.getItem('key1'); + + // Clear the mock to count only clearAll writes + mockFs.writeFile.mockClear(); + + await provider.clearAll(); + + const result1 = await provider.getItem('key1'); + const result2 = await provider.getItem('key2'); + + expect(result1).toBeNull(); + expect(result2).toBeNull(); + expect(mockFs.writeFile).toHaveBeenCalled(); + }); + }); + + describe('updateData', () => { + beforeEach(async () => { + // Setup initialized storage + mockFs.access.mockRejectedValue(new Error('File not found')); + mockFs.mkdir.mockResolvedValue(undefined); + mockFs.writeFile.mockResolvedValue(undefined); + mockFs.rename.mockResolvedValue(undefined); + }); + + it('should update data with modifier function', async () => { + await provider.setItem('counter', '5'); + + await provider.updateData('counter', (current) => { + return (current || 0) + 1; + }); + + const result = await provider.getItem('counter'); + expect(result).toBe('6'); + }); + + it('should handle null current value', async () => { + await provider.updateData('new-key', (current) => { + return current || 'default'; + }); + + const result = await provider.getItem('new-key'); + expect(result).toBe('"default"'); + }); + + it('should propagate business logic errors', async () => { + await expect(provider.updateData('key', () => { + throw new Error('Business logic error'); + })).rejects.toThrow('Business logic error'); + }); + }); + + describe('batchUpdate', () => { + beforeEach(async () => { + // Setup initialized storage + mockFs.access.mockRejectedValue(new Error('File not found')); + mockFs.mkdir.mockResolvedValue(undefined); + mockFs.writeFile.mockResolvedValue(undefined); + mockFs.rename.mockResolvedValue(undefined); + }); + + it('should perform batch operations and write immediately', async () => { + const operations = [ + { key: 'key1', operation: 'set' as const, value: 'value1' }, + { key: 'key2', operation: 'set' as const, value: 'value2' }, + { key: 'key3', operation: 'remove' as const } + ]; + + await provider.batchUpdate(operations); + + expect(await provider.getItem('key1')).toBe('value1'); + expect(await provider.getItem('key2')).toBe('value2'); + expect(await provider.getItem('key3')).toBeNull(); + expect(mockFs.writeFile).toHaveBeenCalled(); + }); + }); + + describe('getCapabilities', () => { + it('should return correct capabilities', () => { + const capabilities = provider.getCapabilities(); + + expect(capabilities).toEqual({ + supportsAtomic: true, + supportsBatch: true, + maxStorageSize: undefined + }); + }); + }); + + describe('flush', () => { + beforeEach(async () => { + // Setup initialized storage + mockFs.access.mockRejectedValue(new Error('File not found')); + mockFs.mkdir.mockResolvedValue(undefined); + mockFs.writeFile.mockResolvedValue(undefined); + mockFs.rename.mockResolvedValue(undefined); + }); + + it('should immediately write pending changes', async () => { + await provider.setItem('key', 'value'); + + // Clear previous write calls + mockFs.writeFile.mockClear(); + + await provider.flush(); + + expect(mockFs.writeFile).toHaveBeenCalled(); + }); + }); +}); diff --git a/packages/core/tests/unit/template/languageService.test.ts b/packages/core/tests/unit/template/languageService.test.ts index dc12d6ed..c133d44e 100644 --- a/packages/core/tests/unit/template/languageService.test.ts +++ b/packages/core/tests/unit/template/languageService.test.ts @@ -24,36 +24,36 @@ describe('TemplateLanguageService', () => { describe('initialization', () => { it('should initialize with default language when no saved preference', async () => { mockStorage.getItem.mockResolvedValue(null); - + await service.initialize(); - - expect(service.getCurrentLanguage()).toBe('en-US'); + + expect(await service.getCurrentLanguage()).toBe('en-US'); expect(service.isInitialized()).toBe(true); }); it('should load saved language preference', async () => { mockStorage.getItem.mockResolvedValue('en-US'); - + await service.initialize(); - - expect(service.getCurrentLanguage()).toBe('en-US'); + + expect(await service.getCurrentLanguage()).toBe('en-US'); expect(mockStorage.getItem).toHaveBeenCalledWith('builtin-template-language'); }); it('should fallback to default language on invalid saved preference', async () => { mockStorage.getItem.mockResolvedValue('invalid-lang'); - + await service.initialize(); - - expect(service.getCurrentLanguage()).toBe('en-US'); + + expect(await service.getCurrentLanguage()).toBe('en-US'); }); it('should handle storage errors gracefully', async () => { mockStorage.getItem.mockRejectedValue(new Error('Storage error')); - + await service.initialize(); - - expect(service.getCurrentLanguage()).toBe('en-US'); + + expect(await service.getCurrentLanguage()).toBe('en-US'); expect(service.isInitialized()).toBe(true); }); }); @@ -65,8 +65,8 @@ describe('TemplateLanguageService', () => { it('should set language successfully', async () => { await service.setLanguage('en-US'); - - expect(service.getCurrentLanguage()).toBe('en-US'); + + expect(await service.getCurrentLanguage()).toBe('en-US'); expect(mockStorage.setItem).toHaveBeenCalledWith('builtin-template-language', 'en-US'); }); @@ -78,26 +78,26 @@ describe('TemplateLanguageService', () => { it('should toggle between languages', async () => { // Start with detected language (en-US in test environment) - expect(service.getCurrentLanguage()).toBe('en-US'); - + expect(await service.getCurrentLanguage()).toBe('en-US'); + // Toggle to Chinese const newLang1 = await service.toggleLanguage(); expect(newLang1).toBe('zh-CN'); - expect(service.getCurrentLanguage()).toBe('zh-CN'); - + expect(await service.getCurrentLanguage()).toBe('zh-CN'); + // Toggle back to English const newLang2 = await service.toggleLanguage(); expect(newLang2).toBe('en-US'); - expect(service.getCurrentLanguage()).toBe('en-US'); + expect(await service.getCurrentLanguage()).toBe('en-US'); }); }); describe('utility methods', () => { - it('should validate languages correctly', () => { - expect(service.isValidLanguage('zh-CN')).toBe(true); - expect(service.isValidLanguage('en-US')).toBe(true); - expect(service.isValidLanguage('fr-FR')).toBe(false); - expect(service.isValidLanguage('')).toBe(false); + it('should validate languages correctly', async () => { + expect(await service.isValidLanguage('zh-CN')).toBe(true); + expect(await service.isValidLanguage('en-US')).toBe(true); + expect(await service.isValidLanguage('fr-FR')).toBe(false); + expect(await service.isValidLanguage('')).toBe(false); }); }); @@ -108,12 +108,12 @@ describe('TemplateLanguageService', () => { value: 'zh-CN', configurable: true }); - + mockStorage.getItem.mockResolvedValue(null); const newService = new TemplateLanguageService(mockStorage); await newService.initialize(); - - expect(newService.getCurrentLanguage()).toBe('zh-CN'); + + expect(await newService.getCurrentLanguage()).toBe('zh-CN'); }); it('should detect English browser language', async () => { @@ -122,12 +122,12 @@ describe('TemplateLanguageService', () => { value: 'en-US', configurable: true }); - + mockStorage.getItem.mockResolvedValue(null); const newService = new TemplateLanguageService(mockStorage); await newService.initialize(); - - expect(newService.getCurrentLanguage()).toBe('en-US'); + + expect(await newService.getCurrentLanguage()).toBe('en-US'); }); it('should default to English for unsupported browser languages', async () => { @@ -141,7 +141,7 @@ describe('TemplateLanguageService', () => { const newService = new TemplateLanguageService(mockStorage); await newService.initialize(); - expect(newService.getCurrentLanguage()).toBe('en-US'); + expect(await newService.getCurrentLanguage()).toBe('en-US'); }); }); diff --git a/packages/desktop/main.js b/packages/desktop/main.js index b8e93977..e90a7a0c 100644 --- a/packages/desktop/main.js +++ b/packages/desktop/main.js @@ -11,11 +11,12 @@ const { createPromptService, createTemplateLanguageService, createDataManager, - StorageFactory, + FileStorageProvider, } = require('@prompt-optimizer/core'); let mainWindow; let modelManager, templateManager, historyManager, llmService, promptService, templateLanguageService, preferenceService, dataManager; +let storageProvider; // 全局存储提供器引用，用于退出时保存数据 async function initializePreferenceService(storageProvider) { console.log('[DESKTOP] Initializing PreferenceService with the provided storage provider...'); @@ -72,6 +73,23 @@ function createWindow() { } } + // 窗口关闭前保存数据 + mainWindow.on('close', async (event) => { + if (storageProvider && typeof storageProvider.flush === 'function') { + event.preventDefault(); // 阻止立即关闭 + + try { + console.log('[DESKTOP] Saving data before window close...'); + await storageProvider.flush(); + console.log('[DESKTOP] Data saved successfully'); + mainWindow.destroy(); // 手动关闭窗口 + } catch (error) { + console.error('[DESKTOP] Failed to save data before close:', error); + mainWindow.destroy(); // 即使保存失败也要关闭 + } + } + }); + // Emitted when the window is closed. mainWindow.on('closed', function () { // Dereference the window object @@ -114,8 +132,24 @@ async function initializeServices() { console.warn('[Main Process] Example: VITE_OPENAI_API_KEY=your_key_here npm start'); } - console.log('[DESKTOP] Creating memory storage provider for Node.js environment'); - const storageProvider = StorageFactory.create('memory'); + console.log('[DESKTOP] Creating file storage provider for desktop environment'); + + // 根据环境确定数据存储路径 + let userDataPath; + if (app.isPackaged) { + // 生产环境：使用可执行文件所在目录下的prompt-optimizer-data文件夹 + const execPath = process.execPath; + const execDir = path.dirname(execPath); + userDataPath = path.join(execDir, 'prompt-optimizer-data'); + console.log('[DESKTOP] Production mode - Executable path:', execPath); + } else { + // 开发环境：使用项目根目录下的prompt-optimizer-data文件夹 + userDataPath = path.join(__dirname, '..', '..', 'prompt-optimizer-data'); + console.log('[DESKTOP] Development mode - Project root data folder'); + } + + console.log('[DESKTOP] Data storage path:', userDataPath); + storageProvider = new FileStorageProvider(userDataPath); await initializePreferenceService(storageProvider); @@ -691,9 +725,26 @@ app.whenReady().then(async () => { }); }); +// 应用退出前保存数据 +app.on('before-quit', async (event) => { + if (storageProvider && typeof storageProvider.flush === 'function') { + event.preventDefault(); // 阻止立即退出 + + try { + console.log('[DESKTOP] Saving data before quit...'); + await storageProvider.flush(); + console.log('[DESKTOP] Data saved successfully'); + } catch (error) { + console.error('[DESKTOP] Failed to save data before quit:', error); + } + + app.quit(); // 手动退出 + } +}); + // Quit when all windows are closed, except on macOS. app.on('window-all-closed', function () { if (process.platform !== 'darwin') { app.quit(); } -}); \ No newline at end of file +}); \ No newline at end of file diff --git a/packages/extension/src/App.vue b/packages/extension/src/App.vue index 40ca43aa..511c30d7 100644 --- a/packages/extension/src/App.vue +++ b/packages/extension/src/App.vue @@ -24,12 +24,12 @@
- + +
+ {{ t('prompt.loading') || '加载中...' }} +
@@ -112,24 +123,29 @@ ref="testPanelRef" class="flex-1 min-w-0 flex flex-col" :prompt-service="promptService" - :original-prompt="prompt" - :optimized-prompt="optimizedPrompt" + :original-prompt="optimizer.prompt" + :optimized-prompt="optimizer.optimizedPrompt" :optimization-mode="selectedOptimizationMode" - v-model="selectedTestModel" - @showConfig="showConfig = true" + v-model="modelManager.selectedTestModel" + @showConfig="modelManager.showConfig = true" /> - - + + @@ -138,7 +154,7 @@